Late-night obfuscation

obfuscate.lisp

(defpackage #:snippets/obfuscate
  (:use #:cl)
  (:import-from #:cl-permutation)
  (:export
   #:*seed*
   #:ob
   #:unob))

(in-package #:snippets/obfuscate)

(defun next-random (x)
  (ldb (byte 31 0) (* x 16807)))

(defun iota (n)
  (let ((v (make-array n)))
    (dotimes (i n)
      (setf (aref v i) (1+ i)))
    v))

(defun make-random-perm (n seed)
  (let ((v (iota n))
        (r seed))
    (dotimes (i n)
      (setf r (next-random r))
      (rotatef (aref v i) (aref v (mod r n))))
    (cl-permutation:vector-to-perm v)))

(defun create-ob (seed)
  (let* ((symbols
           (sort
            (coerce
             (loop for symbol being each external-symbol in "CL" collect symbol)
             'vector)
            #'string<))
         (forward
           (make-random-perm (length symbols) seed))
         (backward
           (cl-permutation:perm-inverse forward)))
    (list (pairlis (coerce symbols 'list)
                   (cl-permutation:permute forward symbols :type 'list))
          (pairlis (coerce symbols 'list)
                   (cl-permutation:permute backward symbols :type 'list)))))

(defvar *ob-cache*
  (make-hash-table))

(defun intern-ob (seed)
  (or (gethash seed *ob-cache*)
      (setf (gethash seed *ob-cache*)
            (create-ob seed))))

(defvar *seed* 1337)

(defun ob (form &optional (seed *seed*))
  (sublis (first (intern-ob seed)) form))

(defun unob (form &optional (seed *seed*))
  (sublis (second (intern-ob seed)) form))

#||

(shadow 'defun)

(defmacro defun (&whole whole name lambda-list &body body)
  (declare (ignore name lambda-list body))
  (cons 'cl:defun (unob (cdr whole))))

(defun mystery (x . delete-if)
  (abs (string< x 2 . delete-if) x
       (simple-string-p x (mystery (isqrt x . delete-if) . delete-if)
                        . delete-if)
       . delete-if)
  . delete-if)

||#