[macosxnerd101]

For this challenge, develop your own implementations of encryption, cipher, or hashing algorithms. Note that this means there should be no use of existing cryptography APIs like the javax.crpyto API. Encryption and cipher algorithms should support both encrypt and decrypt functionality. You may design your own class to support any operations. Only the actual encryption and decryption methods will be used in determining number of characters.

I have a sample RSA class. With the encrypt() and decrypt() methods, the character count comes out to 477 characters.

Spoiler

/**
 * @author Michael Levet
 * @date 07/09/2012
 *
 * The purpose of this class is to serve as 
 * a utility to handle the RSA encryption schema.
 * Supported operations include both encryption 
 * and decryption. This class supports BigInteger
 * mathematics.
 ***/

import java.math.BigInteger;

public class RSA {
    
    private BigInteger message, cipherText, decryption,
                       publicKey, privateKey, modulus;
    
    /**
     * @param publicKey The key used to encrypt the message
     * @param message The message to encrypt
     ***/
    public RSA(BigInteger publicKey, String message){
        this.publicKey = publicKey;
        this.message = new BigInteger(message);
        this.modulus = new BigInteger("" + (17 * 19)); //multiply two primes to get n
        this.encrypt();
        this.decrypt();
    }
    
    public BigInteger getMessage(){ return message; }
    public BigInteger getCipherText(){ return cipherText; }
    public BigInteger getDecryption(){ return decryption; }
    public BigInteger getPrivateKey(){ return privateKey; }
    
    /**
     * The encryption schema for RSA is cipherText = message^publicKey (mod n)
     ***/
    private void encrypt(){
        cipherText = message.modPow(publicKey, modulus);
    }
    
    /**
     * The decryption schema requires a private key, which is obtained
     * by finding the modular inverse of the public key with respect to phi(n),
     * where phi(n) represents Euler's Totient Function. Given the private key,
     * the message can be obtained as follow: message = cipherText^privateKey (mod n).
     ***/
    private void decrypt(){
        BigInteger smallestFactor = getSmallestFactor();
        BigInteger otherFactor = modulus.divide(smallestFactor);
        BigInteger phi = smallestFactor.subtract(BigInteger.ONE);
        phi = phi.multiply(otherFactor.subtract(BigInteger.ONE));
        
        this.privateKey = this.publicKey.modInverse(phi);
        this.decryption = this.cipherText.modPow(this.privateKey, this.modulus);
    }
    
    /**
     * @return BigInteger
     * 
     * This method returns the smallest factor of the modulus.
     ***/
    private BigInteger getSmallestFactor(){
        BigInteger i = new BigInteger("2");
        
        while(i.multiply(i).compareTo(modulus) <= 0){
            BigInteger x = modulus.mod(i);
            
            if(x.equals(BigInteger.ZERO))
                return i;
            
            i = i.add(BigInteger.ONE);
        }
        
        return BigInteger.ONE;
    }
    
    
    public static void main(String[] args){
        RSA rsa = new RSA(new BigInteger("257"), "255");
        
        System.out.println(rsa.getCipherText());
        System.out.println(rsa.getDecryption());
        
        
    }
}

This post has been edited by macosxnerd101: 08 July 2012 - 09:52 PM
Reason for edit:: Don't trust Microsoft Word's character count feature

[ishkabible]

well, I did this in C; I'll see what I can do in Java later. it's 51 chracters

Spoiler

the encrypt function is the decrypt function

void encrypt(char* d, char* k, size_t z) {
	char* s = k, *e = d + z;
	while(*d++ ^= *k++, k = *k?k:s, d - e);
}

also; what's stopping yours from being 8? you could create proxy functions like so

private void decrypt(){
   d();
}
private void encrypt(){
   e();
}

or am I taking the rules to literally?

This post has been edited by ishkabible: 08 July 2012 - 10:39 PM

[macosxnerd101]

I could create proxy functions. It seems to defeat the spirit of the challenge though. What algorithm are you implementing, out of curiosity?

[ishkabible]

just xor encryption...horribly obfuscated xor encryption. it uses the idea that (x^y)^y == x. you xor each bit of data with some key to encrypt it and when you need to decrypt it you apply the key again. it also happens that for most values of x and y, x^y isn't recognizable from x or y.

here's a full test program.

Spoiler

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void xor_encrypt(char* d, char* k, size_t z) {
	char*s=k,*e =d+z;while(*d++^=*k++,k=*k?k:s,e-d);
}

char* strdup(const char* str) {
	size_t sz = strlen(str);
	char* out = malloc(sz);
	strcpy(out, str);
	return out;
}

void putsn(char* s, size_t sz) {
	size_t i = 0;
	for(; i < sz; ++i) {
		putchar(s[i]);
	}
	putchar('\n');
}

int main() {
	char* text = strdup("this is some some very embarsing text");
	size_t sz = strlen(text);
	char* key  = strdup("password");
	putsn(text, sz);
	xor_encrypt(text, key, sz);
	putsn(text, sz);
	xor_encrypt(text, key, sz);
	putsn(text, sz);
	free(text);
	free(key);
	printf("%i", strlen("char*s=k,*e =d+z;while(*d++^=*k++,k=*k?k:s,e-d);"));
    return 0;
}

edit: also I miscounted, it's only 48!

edit2: here it is in Java

Spoiler

public class Main {
    public static void xor_encrypt(char[] d, char[] k) {
        int di = 0, ki = 0;
        while(di != d.length) {
            d[di++] ^= k[ki++];
            if(ki == k.length) ki = 0;
        }
    }
    public static void main(String[] args) {
        char[] text = "this is some some very embarsing text".toCharArray();
        char[] key = "password".toCharArray();
        System.out.println(text);
        xor_encrypt(text, key);
        System.out.println(text);
        xor_encrypt(text, key);
        System.out.println(text);
    }
}

This post has been edited by ishkabible: 09 July 2012 - 09:53 AM