/rsa.rkt

#lang racket
(require racket/include)
(include "primality.rkt")
  

(define dec->bin
  (lambda (d)
    (cond
      ((< d 1) (list 0))
      ((= d 1) (list 1))
      ((> d 1) (append
                (dec->bin (floor (/ d 2)))
		(list (if (= (modulo d 2) 0) 0 1))))
      )))

(define (totient p q) (*(- p 1) (- q 1)))

(define (coprime n)
  (let ((nr (random n)))
  (cond
    ((= (gcd n 17) 1) 17)
    ((= (gcd n nr) 1) nr)
    (else (coprime n))
    )))

(define (extEuclidean a b)
  (cond
    ((= b 0) (list 1 0 a))
    (else 
     (let ((eAnswer (extEuclidean b (remainder a b))))
           (list (cadr eAnswer)
                 (- (car eAnswer) (* (cadr eAnswer) (floor (/ a b))))
                 (car (cddr eAnswer)))
     ))))
(define (modInvEuclid a m)  (remainder (+ m (car (extEuclidean a m))) m))

(define (quickExponentiate a b c)
  (remainder (quickExponentiate-helper (reverse (dec->bin b)) c (reverse (quickExpPowers a c (floor (+ (/ (log b) (log 2)) 1)) '() ))) c)
  )
(define (quickExponentiate-helper b c n)
  (cond
    ((null? b) 1)
    ((= (car b) 0) (quickExponentiate-helper (cdr b) c (cdr n)))
    (else (* (car n) (quickExponentiate-helper (cdr b) c (cdr n))))
    ))
(define (quickExpPowers a c k n)
  (cond
    ((= k (length n)) n)
    ((null? n) (quickExpPowers a c k (list (remainder a c))))
    (else (quickExpPowers a c k (cons (remainder (pow (car n) 2) c) n)))
    ))

(define (rsa-keygen p q)
  (let ((n (* p q)) (t (totient p q)))
    (let ((e (coprime n)))
      (let ((d (modInvEuclid e t)))
      (cond
        ((equal? d #f) #f)
        (else (list (list n e) (list n d)))
        ))
      )
    ))

(define (rsa-encrypt public-key info) (quickExponentiate info (cadr public-key) (car public-key)))
(define (rsa-decrypt private-key info) (quickExponentiate info (cadr private-key) (car private-key)))