Max 5 API Reference

jit.cp.c

/* 
    jit.cp.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
        
*/



#include "jit.common.h"
#include "ext_path.h"

#if (0) // NOT USED

#include <Gestalt.h>
#include <Errors.h>
#include <NameRegistry.h>
#include <stdio.h>
#include <Strings.h>
#include <OpenTransport.h>
#include <OpenTptLinks.h>
#include <OpenTptConfig.h>

struct Address8022
{
    OTAddressType   fAddrFamily;
    UInt8           fHWAddr[k48BitAddrLength];
    UInt16          fSAP;
    UInt8           fSNAP[k8022SNAPLength];
};
typedef struct Address8022 Address8022;

#endif // NOT USED

//cp1
static long malibu(char c)
{
    switch (c) {
    case 'P':   return 0;
    case '9':   return 1;
    case 'G':   return 2;
    case 'E':   return 3;
    case 'Q':   return 4;
    case '3':   return 5;
    case 'N':   return 6;
    case 'F':   return 7;
    case '2':   return 8;
    case 'K':   return 9;
    case '4':   return 10;
    case '8':   return 11;
    case '7':   return 12;
    case 'Y':   return 13;
    case 'S':   return 14;
    case 'U':   return 15;
    default:    return -1;
    }
}

static char beach(long c)
{
    switch (c%16) {
    case 0:     return 'P';
    case 1:     return '9';
    case 2:     return 'G';
    case 3:     return 'E';
    case 4:     return 'Q';
    case 5:     return '3';
    case 6:     return 'N';
    case 7:     return 'F';
    case 8:     return '2';
    case 9:     return 'K';
    case 10:    return '4';
    case 11:    return '8';
    case 12:    return '7';
    case 13:    return 'Y';
    case 14:    return 'S';
    case 15:    return 'U';
    default:    return -1;
    }
}

//cp2
static long little(char c)
{
    switch (c) {
    case 'W':   return 0;
    case 'C':   return 1;
    case '6':   return 2;
    case '3':   return 3;
    case '4':   return 4;
    case 'A':   return 5;
    case 'X':   return 6;
    case 'E':   return 7;
    case 'L':   return 8;
    case '2':   return 9;
    case 'J':   return 10;
    case '7':   return 11;
    case 'R':   return 12;
    case 'Z':   return 13;
    case 'M':   return 14;
    case '5':   return 15;
    default:    return -1;
    }
}

static char pony(long c)
{
    switch (c%16) {
    case 0:     return 'W';
    case 1:     return 'C';
    case 2:     return '6';
    case 3:     return '3';
    case 4:     return '4';
    case 5:     return 'A';
    case 6:     return 'X';
    case 7:     return 'E';
    case 8:     return 'L';
    case 9:     return '2';
    case 10:    return 'J';
    case 11:    return '7';
    case 12:    return 'R';
    case 13:    return 'Z';
    case 14:    return 'M';
    case 15:    return '5';
    default:    return -1;
    }
}

//cp3
static long satin(char c)
{
    switch (c) {
    case '2':   return 0;
    case 'K':   return 1;
    case '9':   return 2;
    case '5':   return 3;
    case 'Z':   return 4;
    case '3':   return 5;
    case 'B':   return 6;
    case 'N':   return 7;
    case '4':   return 8;
    case 'S':   return 9;
    case 'T':   return 10;
    case 'M':   return 11;
    case '6':   return 12;
    case '8':   return 13;
    case 'C':   return 14;
    case 'W':   return 15;
    default:    return -1;
    }
}

static char skies(long c)
{
    switch (c%16) {
    case 0:     return '2';
    case 1:     return 'K';
    case 2:     return '9';
    case 3:     return '5';
    case 4:     return 'Z';
    case 5:     return '3';
    case 6:     return 'B';
    case 7:     return 'N';
    case 8:     return '4';
    case 9:     return 'S';
    case 10:    return 'T';
    case 11:    return 'M';
    case 12:    return '6';
    case 13:    return '8';
    case 14:    return 'C';
    case 15:    return 'W';
    default:    return -1;
    }
}

//cp4
static long cotton(char c)
{
    switch (c) {
    case 'X':   return 0;
    case '3':   return 1;
    case 'F':   return 2;
    case 'G':   return 3;
    case 'A':   return 4;
    case 'H':   return 5;
    case 'R':   return 6;
    case 'W':   return 7;
    case '6':   return 8;
    case '9':   return 9;
    case '4':   return 10;
    case '2':   return 11;
    case 'M':   return 12;
    case 'E':   return 13;
    case '5':   return 14;
    case '7':   return 15;
    default:    return -1;
    }
}

static char candy(long c)
{
    switch (c%16) {
    case 0:     return 'X';
    case 1:     return '3';
    case 2:     return 'F';
    case 3:     return 'G';
    case 4:     return 'A';
    case 5:     return 'H';
    case 6:     return 'R';
    case 7:     return 'W';
    case 8:     return '6';
    case 9:     return '9';
    case 10:    return '4';
    case 11:    return '2';
    case 12:    return 'M';
    case 13:    return 'E';
    case 14:    return '5';
    case 15:    return '7';
    default:    return -1;
    }
}

//one of four(based on last)
static long jiminy(long a, char b)
{
    long t;
    
    switch(a%4) {
    case 0:     t = malibu(b);  break;
    case 1:     t = little(b);  break;
    case 2:     t = satin(b);   break;
    case 3:     t = cotton(b);  break;
    default:    return -1;
    }
    
    if (t<0) return -1;
    
    t -= a%16;
    if (t<0) t += 16;
    
    return t;
}

static char cricket(long a, long b)
{
    switch(a%4) {
    case 0:     return beach(a+b);
    case 1:     return pony(a+b);
    case 2:     return skies(a+b);
    case 3:     return candy(a+b);
    default:    return -1;
    }   
}

void creepy(char *a, uchar *b) //decode
{
    long t0,t1,t2,t3;
    long v0,v1;
    
    t0 = malibu(a[0]); //always starts with malibu
    t1 = jiminy(t0,a[1]);
    t2 = jiminy(t1,a[2]);
    t3 = jiminy(t2,a[3]);
    
    //funky stuff
    v0 = jiminy(t0*t1+t1+t2,a[4]);
    v1 = jiminy(t1*t2+v0,a[5]);
    
    b[0] = ((v0<<4L)|v1);
    
    v0 = jiminy(t0+t3,a[6]);
    v1 = jiminy(t1+t2+v0,a[7]);
    
    b[1] = ((v0<<4L)|v1);

    v0 = jiminy(t2*t3+t1+t2,a[8]);
    v1 = jiminy(t1*t3+v0,a[9]);
    
    b[2] = ((v0<<4L)|v1);
    
    v0 = jiminy(t2+t3,a[10]);
    v1 = jiminy(t0+t3+v0,a[11]);
    
    b[3] = ((v0<<4L)|v1);

    v0 = jiminy(t1*t3+t1+t2,a[12]);
    v1 = jiminy(t0*t2+v0,a[13]);
    
    b[4] = ((v0<<4L)|v1);

    v0 = jiminy(t1+t2,a[14]);
    v1 = jiminy(t1+t3+v0,a[15]);
    
    b[5] = ((v0<<4L)|v1);

}

void crawly(uchar *a, char *b) //inverse
{
    uchar t0,t1,t2,t3;
    
    jit_rand_setseed(0);
    jit_rand(); //once for good measure

    t0 = (jit_rand()>>16L)%16;
    b[0] = beach(t0); //always starts with malibu
    t1 = (jit_rand()>>16L)%16;
    b[1] = cricket(t0,t1);
    t2 = (jit_rand()>>16L)%16;
    b[2] = cricket(t1,t2);
    t3 = (jit_rand()>>16L)%16;
    b[3] = cricket(t2,t3);
    
    //funky stuff
    b[4]    = cricket(t0*t1+t1+t2,a[0]>>4L);
    b[5]    = cricket(t1*t2+(a[0]>>4L),a[0]&0x0f);
        
    b[6]    = cricket(t0+t3,a[1]>>4L);
    b[7]    = cricket(t1+t2+(a[1]>>4L),a[1]&0x0f);
    
    b[8]    = cricket(t2*t3+t1+t2,a[2]>>4L);
    b[9]    = cricket(t1*t3+(a[2]>>4L),a[2]&0x0f);
        
    b[10]   = cricket(t2+t3,a[3]>>4L);
    b[11]   = cricket(t0+t3+(a[3]>>4L),a[3]&0x0f);
    
    b[12]   = cricket(t1*t3+t1+t2,a[4]>>4L);
    b[13]   = cricket(t0*t2+(a[4]>>4L),a[4]&0x0f);

    b[14]   = cricket(t1+t2,a[5]>>4L);
    b[15]   = cricket(t1+t3+(a[5]>>4L),a[5]&0x0f);
    
}

void creepy2(char *a, uchar *b) //decode
{
    long t0,t1,t2,t3;
    long v0,v1;
    
    t0 = cotton(a[0]); //always starts with coton
    t1 = jiminy(t0,a[1]);
    t2 = jiminy(t1,a[2]);
    t3 = jiminy(t2,a[3]);
    
    //funky stuff
    v0 = jiminy(t0*t1+t1+t2,a[4]);
    v1 = jiminy(t1*t2+v0,a[5]);
    
    b[0] = ((v0<<4L)|v1);
    
    v0 = jiminy(t0+t3,a[6]);
    v1 = jiminy(t1+t2+v0,a[7]);
    
    b[1] = ((v0<<4L)|v1);

    v0 = jiminy(t2*t3+t1+t2,a[8]);
    v1 = jiminy(t1*t3+v0,a[9]);
    
    b[2] = ((v0<<4L)|v1);
    
    v0 = jiminy(t2+t3,a[10]);
    v1 = jiminy(t0+t3+v0,a[11]);
    
    b[3] = ((v0<<4L)|v1);

    v0 = jiminy(t1*t3+t1+t2,a[12]);
    v1 = jiminy(t0*t2+v0,a[13]);
    
    b[4] = ((v0<<4L)|v1);

    v0 = jiminy(t1+t2,a[14]);
    v1 = jiminy(t1+t3+v0,a[15]);
    
    b[5] = ((v0<<4L)|v1);

}

void crawly2(uchar *a, char *b) 
{
    uchar t0,t1,t2,t3;

    jit_rand_setseed(0);
    jit_rand(); //once for good measure
    
    t0 = (jit_rand()>>16L)%16;
    b[0] = candy(t0); //always starts with coton
    t1 = (jit_rand()>>16L)%16;
    b[1] = cricket(t0,t1);
    t2 = (jit_rand()>>16L)%16;
    b[2] = cricket(t1,t2);
    t3 = (jit_rand()>>16L)%16;
    b[3] = cricket(t2,t3);
    
    //funky stuff
    b[4]    = cricket(t0*t1+t1+t2,a[0]>>4L);
    b[5]    = cricket(t1*t2+(a[0]>>4L),a[0]&0x0f);
        
    b[6]    = cricket(t0+t3,a[1]>>4L);
    b[7]    = cricket(t1+t2+(a[1]>>4L),a[1]&0x0f);
    
    b[8]    = cricket(t2*t3+t1+t2,a[2]>>4L);
    b[9]    = cricket(t1*t3+(a[2]>>4L),a[2]&0x0f);
        
    b[10]   = cricket(t2+t3,a[3]>>4L);
    b[11]   = cricket(t0+t3+(a[3]>>4L),a[3]&0x0f);
    
    b[12]   = cricket(t1*t3+t1+t2,a[4]>>4L);
    b[13]   = cricket(t0*t2+(a[4]>>4L),a[4]&0x0f);

    b[14]   = cricket(t1+t2,a[5]>>4L);
    b[15]   = cricket(t1+t3+(a[5]>>4L),a[5]&0x0f);  
}

#if (0) // NOT USED

OSErr    AddFileID(short vrefnum, long dirID, char *name, long *fileID)
{
    OSErr            err;
    HParmBlkPtr        h;

    h = (HParmBlkPtr)NewPtrClear(sizeof(HParamBlockRec));

    h->fidParam.ioCompletion = nil;
    h->fidParam.ioNamePtr = name;
    h->fidParam.ioVRefNum = vrefnum;
    h->fidParam.ioSrcDirID = dirID;

    err = PBCreateFileIDRefSync(h);
    *fileID = h->fidParam.ioFileID;
    DisposePtr((void *)h);
    return(err);
}

OSErr    GetFileID(short vrefnum, long dirID, char *name, long *fileID)
{
    OSErr            err;
    CInfoPBPtr        cInfo;

    cInfo = (CInfoPBPtr)NewPtrClear(sizeof(CInfoPBRec));

    cInfo->hFileInfo.ioCompletion = nil;
    cInfo->hFileInfo.ioNamePtr = name;
    cInfo->hFileInfo.ioVRefNum = vrefnum;
    cInfo->hFileInfo.ioFDirIndex = 0;
    cInfo->hFileInfo.ioDirID = dirID;

    err = PBGetCatInfoSync(cInfo);
    *fileID = cInfo->hFileInfo.ioDirID;
    DisposePtr((void *)cInfo);
    return(err);
}

static char p_tinkerbell[] = {11,'.','t','i','n','k','e','r','b','e','l','l'};
#define kOnSystemDisk -32768

long jit_cp_cfile_read(short vrefnum, long dirID, uchar *b)
{
    short refnum;
    long count=529;
    OSErr err;
    
    if (err=HOpenDF(vrefnum,dirID,p_tinkerbell,fsRdPerm,&refnum)) {
        jit_object_post((t_object *)x,"copy protection open file error: %d",err);
        return -1;
    }
    FSRead(refnum,&count,b);
    FSClose(refnum);
}

long jit_cp_cfile_find(short *vrefnum, long *dirID, long *fileID)
{
    OSErr err;
    short refnum;
    //find file in preferences file named .tinkerbell
    
    //assuming we have findfolder capabilities(i think this is safe, no?)
    FindFolder(kOnSystemDisk,'pref',TRUE,vrefnum,dirID);
    
    if (*dirID) {
        err = HOpenDF(*vrefnum,*dirID,p_tinkerbell,fsRdPerm,&refnum);
        if (!err) { //should test for errors which are acceptable
            FSClose(refnum);
            GetFileID(*vrefnum,*dirID,p_tinkerbell,fileID);
            if (*fileID==0) {
                jit_object_post((t_object *)x,"copy protection find file error: 1");
                AddFileID(*vrefnum,*dirID,p_tinkerbell,fileID);//just in case someone makes their own file
                GetFileID(*vrefnum,*dirID,p_tinkerbell,fileID);
            }
            return 0;
        } else {
        //  jit_object_post((t_object *)x,"copy protection find file error: %d",err);
            return -1;
        }
    } else {
        jit_object_post((t_object *)x,"copy protection find file error: 2");
        return -1;
    }
}

long jit_cp_cfile_get(uchar *b)
{
    uchar b2[529];
    long fileID=0;
    short vrefnum=0;
    long dirID=0;

    if (jit_cp_cfile_find(&vrefnum,&dirID,&fileID))
        return -1;
    
    if (jit_cp_cfile_read(vrefnum,dirID,&b2))
        return -2;
        
    //key uses file id, dir id, and bytes from file
    b[0] = ((uchar *)(&fileID))[2];
    b[1] = ((uchar *)(&fileID))[3];
    b[2] = ((uchar *)(&dirID))[2];
    b[3] = ((uchar *)(&dirID))[3];
    b[4] = b2[((uchar *)(&fileID))[2]];
    b[5] = b2[((uchar *)(&fileID))[3]];
    
//  jit_object_post((t_object *)x,"cfile get %x:%x:%x:%x:%x:%x",b[0],b[1],b[2],b[3],b[4],b[5]);
    
    return 0;
}


long jit_cp_cfile_make(uchar *b)
{
    long fileID=0;
    short vrefnum=0;
    short refnum=0;
    long dirID=0;
    uchar byte;
    long count;
    OSErr err;
    long i;
    FInfo finfo;

    //find file in preferences folder named .tinkerbell
    if (jit_cp_cfile_find(&vrefnum,&dirID,&fileID)) {
        if (dirID) {
            //1. make tinkerbell file
            err = HCreate(vrefnum,dirID,p_tinkerbell,'????','????');
            if (err) jit_object_post((t_object *)x,"copy protection create file error: %d",err);
            //2. fill with 529 bytes of random data
            HOpenDF (vrefnum,dirID,p_tinkerbell,fsWrPerm,&refnum);
            for (i=0;i<529;i++) {
                count = 1;
                byte = jit_rand();
                FSWrite(refnum,&count,&byte);
            }           
            FSClose(refnum);
            //3. add file id
            AddFileID(vrefnum,dirID,p_tinkerbell,&fileID);
                        
            //make invisible
            HGetFInfo (vrefnum,dirID,p_tinkerbell,&finfo);  
            finfo.fdFlags |= kIsInvisible;
            HSetFInfo (vrefnum,dirID,p_tinkerbell,&finfo);
        }
    }

    jit_cp_cfile_get(b);
    
    return 0;
}


//obsoleted...remove at beta stage
long jit_get_enetaddr(uchar *b)
{
    OSStatus        status;
    EndpointRef     ep;
    OTPortRecord    devicePortRecord;
    UInt32          index;
    TBind           returnInfo;
    TBind           requestInfo;
    Address8022     theReturnAddr =     {AF_8022, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x0000,
                                        {0x00,0x00,0x00,0x00,0x00}};
    Address8022     theAddr =   {AF_8022, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x8888,
                                    {0x00,0x00,0x00,0x00,0x00}};
    Boolean         foundAPort;
    long            gotcha=0;
    
    
    if (status = InitOpenTransport())
    {
//      jit_object_post((t_object *)x,"Open Transport is not installed or is inactive: error %d",status);
        return -1;
    }
    else
    {
        //jit_object_post((t_object *)x,"Now checking for Ethernet addresses using Open Transport");
    }

    index = 0;
    // iterate thru each OT port record for ethernet ports. 
    while (foundAPort = OTGetIndexedPort(&devicePortRecord,index))
    {
//      jit_object_post((t_object *)x,"opening OT port %d",index);
        if ((devicePortRecord.fCapabilities & kOTPortIsDLPI) &&
            (devicePortRecord.fCapabilities & kOTPortIsTPI) &&
            (kOTEthernetDevice == OTGetDeviceTypeFromPortRef(devicePortRecord.fRef)))
        {   
//          jit_object_post((t_object *)x,"port %d is ethernet device",index);
            ep = OTOpenEndpoint(OTCreateConfiguration(devicePortRecord.fPortName), (OTOpenFlags)NULL, NULL,&status);
    
            if (status == kOTNoError)
            {
//              jit_object_post((t_object *)x,"opened endpoint for port %d",index);
                // we have to bind the endpoint before we can get it's address info
                requestInfo.addr.buf = (UInt8 *)&theAddr;
                requestInfo.addr.len = 10;  // family type + Ethernet + type field
                                // don't use sizeof(theAddr) since we are binding to type 1 Ethernet
                                // address, not to an 802.2 address.
                requestInfo.addr.maxlen = 0;            
                requestInfo.qlen = 0;
                
                ///******************************************************************
                // OTBind is not working when the serial port is enabled for appletalk
                // MUST FIX!!! 
                status = OTBind(ep, &requestInfo, NULL);

                if (status == kOTNoError)
                {
//                  jit_object_post((t_object *)x,"bound port %d",index);
                    returnInfo.addr.buf = (UInt8 *)&theReturnAddr;
                    returnInfo.addr.maxlen = 10;            // family type + 6 bytes for Ethernet + type
                    returnInfo.qlen = 0;
                                
                    status = OTGetProtAddress(ep,&returnInfo,NULL);
                    
                    if (status == kOTNoError)
                    {
//                      jit_object_post((t_object *)x,"got port %d address",index);
                        if (!gotcha) {
                            gotcha = 1;
                            b[0] = theReturnAddr.fHWAddr[0];
                            b[1] = theReturnAddr.fHWAddr[1];
                            b[2] = theReturnAddr.fHWAddr[2];
                            b[3] = theReturnAddr.fHWAddr[3];
                            b[4] = theReturnAddr.fHWAddr[4];
                            b[5] = theReturnAddr.fHWAddr[5];
//                          jit_object_post((t_object *)x,"%x:%x:%x:%x:%x:%x",b[0],b[1],b[2],b[3],b[4],b[5]);
                        }           
                    }
                    OTUnbind(ep);
                }
                OTCloseProvider(ep);
            } else {
//              jit_object_post((t_object *)x,"port %d is ethernet device",index);
            }       
        }
        index++;
    }   
    // closing down
    CloseOpenTransport();   
    return 0;
}

long jit_cp_isauth(void)
{
    char    chal[16];
    uchar   uid[6];
    uchar   uid2[6];
    char    jitkey[MAX_PATH_CHARS];
    short   vol;
    t_filehandle ref;
    long    count;
    long    type;
    long    err;

    uid[0] = 0;
    uid[1] = 0;
    uid[2] = 0;
    uid[3] = 0;
    uid[4] = 0;
    uid[5] = 0;

    if (err=jit_cp_cfile_get(&uid)) {
        //still support ethernet based keys for those who have them already
        if (jit_get_enetaddr(&uid)|| 
            (!(uid[0]|uid[1]|uid[2]|uid[3]|uid[4]|uid[5]))) { //addy all zeros?
            goto out;
        }
//      jit_object_post((t_object *)x,"using retro cp(err=%d)",err);
        
    }
    sprintf(jitkey,":.jitkey");
    if (!locatefile_extended(jitkey, &vol, &type, 0L, 0)) {//find file jitkey
        if (path_opensysfile(jitkey, vol, &ref, READ_PERM)) {
            jit_object_post((t_object *)x,"error opening jitkey");
            goto out;
        }
        count = 16;
        sysfile_read(ref,&count,chal);
        sysfile_close(ref);

        creepy2(chal,uid2);
//      jit_object_post((t_object *)x,"jitkey valid for %x:%x:%x:%x:%x:%x",uid2[0],uid2[1],uid2[2],uid2[3],uid2[4],uid2[5]);
        if ((uid[0]==uid2[0]) &&
            (uid[1]==uid2[1]) &&
            (uid[2]==uid2[2]) &&
            (uid[3]==uid2[3]) &&
            (uid[4]==uid2[4]) &&
            (uid[5]==uid2[5])) {
            
            jit_object_post((t_object *)x,"jit installed");
        
            return 1;       
        } else {
            jit_object_post((t_object *)x,"jitkey not compatible with this machine");   
            /*
            if (uid[0]!=uid2[0]) jit_object_post((t_object *)x,"invalid[0]");
            if (uid[1]!=uid2[1]) jit_object_post((t_object *)x,"invalid[1]");
            if (uid[2]!=uid2[2]) jit_object_post((t_object *)x,"invalid[2]");
            if (uid[3]!=uid2[3]) jit_object_post((t_object *)x,"invalid[3]");
            if (uid[4]!=uid2[4]) jit_object_post((t_object *)x,"invalid[4]");
            if (uid[5]!=uid2[5]) jit_object_post((t_object *)x,"invalid[5]");
            */
        }
    }
out:    
    jit_object_post((t_object *)x,"jit is not authorized for this machine");
    jit_object_post((t_object *)x,"please send the following challenge to");
    jit_object_post((t_object *)x,"jkc@cycling74.com to receive jitkey");

    //write file.
    jit_cp_cfile_make(&uid);

//  jit_object_post((t_object *)x,"uid is %x:%x:%x:%x:%x:%x",uid[0],uid[1],uid[2],uid[3],uid[4],uid[5]);

    crawly(uid,chal);
    jit_object_post((t_object *)x,"challenge: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
        chal[0],chal[1],chal[2],chal[3],
        chal[4],chal[5],chal[6],chal[7],
        chal[8],chal[9],chal[10],chal[11],
        chal[12],chal[13],chal[14],chal[15]);   
/*
    crawly2(uid,chal);
    jit_object_post((t_object *)x,"response: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
        chal[0],chal[1],chal[2],chal[3],
        chal[4],chal[5],chal[6],chal[7],
        chal[8],chal[9],chal[10],chal[11],
        chal[12],chal[13],chal[14],chal[15]);   
*/

    return 0;
}

#endif //NOT USED

Copyright © 2008, Cycling '74