自学教程：C++ ARCH_INDEX函数代码示例

/* ------- Binary ------- */void * sha512_common_binary(char *ciphertext){	static unsigned char * out;	char *p;	int i;	if (!out) out = mem_calloc_tiny(BINARY_SIZE, MEM_ALIGN_WORD);	p = ciphertext + TAG_LENGTH;	for (i = 0; i < BINARY_SIZE; i++) {		out[i] =				(atoi16[ARCH_INDEX(*p)] << 4) |				 atoi16[ARCH_INDEX(p[1])];		p += 2;	}#ifdef SIMD_COEF_64	alter_endianity_to_BE64(out, BINARY_SIZE/8);#endif	return out;}

/* We're essentially using three salts, but we're going to pack it into a single blob for now.   |Client Challenge (8 Bytes)|Server Challenge (8 Bytes)|Unicode(Username (<=20).Domain (<=15))*/static void *get_salt(char *ciphertext){  static unsigned char *binary_salt;  unsigned char identity[USERNAME_LENGTH + DOMAIN_LENGTH + 1];  UTF16 identity_ucs2[USERNAME_LENGTH + DOMAIN_LENGTH + 1];  int i, identity_length;  int identity_ucs2_length;  char *pos = NULL;  if (!binary_salt) binary_salt = mem_alloc_tiny(SALT_SIZE, MEM_ALIGN_WORD);  /* Calculate identity length */  for (pos = ciphertext + 9; *pos != '$'; pos++);  identity_length = pos - (ciphertext + 9);  /* Convert identity (username + domain) string to NT unicode */  strnzcpy((char *)identity, ciphertext + 9, sizeof(identity));  identity_ucs2_length = enc_to_utf16((UTF16 *)identity_ucs2, USERNAME_LENGTH + DOMAIN_LENGTH, (UTF8 *)identity, identity_length) * sizeof(int16);  if (identity_ucs2_length < 0) // Truncated at Unicode conversion.	  identity_ucs2_length = strlen16((UTF16 *)identity_ucs2) * sizeof(int16);  binary_salt[16] = (unsigned char)identity_ucs2_length;  memcpy(&binary_salt[17], (char *)identity_ucs2, identity_ucs2_length);  /* Set server challenge */  ciphertext += 10 + identity_length;  for (i = 0; i < 8; i++)    binary_salt[i] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];  /* Set client challenge */  ciphertext += 2 + CHALLENGE_LENGTH / 2 + CIPHERTEXT_LENGTH;  for (i = 0; i < 8; ++i)    binary_salt[i + 8] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];  /* Return a concatenation of the server and client challenges and the identity value */  return (void*)binary_salt;}

//code from historical JtR phpass patchstatic void *get_binary(char *ciphertext){	static unsigned char b[BINARY_SIZE];	int i, bidx = 0;	unsigned sixbits;	char *pos = &ciphertext[3 + 1 + 8];	memset(b, 0, BINARY_SIZE);	for (i = 0; i < 5; i++) {		sixbits = atoi64[ARCH_INDEX(*pos++)];		b[bidx] = sixbits;		sixbits = atoi64[ARCH_INDEX(*pos++)];		b[bidx++] |= (sixbits << 6);		sixbits >>= 2;		b[bidx] = sixbits;		sixbits = atoi64[ARCH_INDEX(*pos++)];		b[bidx++] |= (sixbits << 4);		sixbits >>= 4;		b[bidx] = sixbits;		sixbits = atoi64[ARCH_INDEX(*pos++)];		b[bidx++] |= (sixbits << 2);	}	sixbits = atoi64[ARCH_INDEX(*pos++)];	b[bidx] = sixbits;	sixbits = atoi64[ARCH_INDEX(*pos++)];	b[bidx] |= (sixbits << 6);	return (void *) b;}

static void * wpapsk_binary(char *ciphertext) {	static unsigned char realcipher[BINARY_SIZE];	int i,pos;		for(i=0;ciphertext[i]!='#';i++);	pos=i+1;	for(i=0;i<BINARY_SIZE;i++)	{		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2+pos])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+1+pos])];	}	pos += i*2+1;	i=0;	while(ciphertext[pos]!=' ')	{		DATA[i] = atoi16[ARCH_INDEX(ciphertext[pos])]*16 + atoi16[ARCH_INDEX(ciphertext[1+pos])];		i++;		pos += 2;	}	memcpy(nDATA+23, DATA, 12+64);	pos++;	i=0;	while(ciphertext[pos])	{		EAPOL[i] = atoi16[ARCH_INDEX(ciphertext[pos])]*16 + atoi16[ARCH_INDEX(ciphertext[1+pos])];		i++;		pos += 2;	}	return (void *)realcipher;}

static void *get_salt(char *ciphertext){	char *ctcopy = strdup(ciphertext);	char *keeptr = ctcopy;	int i;	char *p;	salt_struct = mem_calloc_tiny(sizeof(struct custom_salt),	                              MEM_ALIGN_WORD);	ctcopy += 11;	/* skip over "$keychain$*" */	p = strtokm(ctcopy, "*");	for (i = 0; i < SALTLEN; i++)		salt_struct->salt[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtokm(NULL, "*");	for (i = 0; i < IVLEN; i++)		salt_struct->iv[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtokm(NULL, "*");	for (i = 0; i < CTLEN; i++)		salt_struct->ct[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	MEM_FREE(keeptr);	return (void *)salt_struct;}

static void *get_salt(char *ciphertext){	char *ctcopy = strdup(ciphertext);	char *keeptr = ctcopy;	int i;	char *p;	ctcopy += 5;	/* skip over "$pdf$" marker */	salt_struct = mem_calloc_tiny(sizeof(struct custom_salt), MEM_ALIGN_WORD);	/* restore serialized data */	salt_struct->e.s_handler = strtok(ctcopy, "*");	salt_struct->e.o_string = (uint8_t *) malloc(32);	p = strtok(NULL, "*");	for (i = 0; i < 32; i++)		salt_struct->e.o_string[i] =		    atoi16[ARCH_INDEX(p[i * 2])] * 16 +		    atoi16[ARCH_INDEX(p[i * 2 + 1])];	salt_struct->e.u_string = (uint8_t *) malloc(32);	p = strtok(NULL, "*");	for (i = 0; i < 32; i++)		salt_struct->e.u_string[i] =		    atoi16[ARCH_INDEX(p[i * 2])] * 16 +		    atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtok(NULL, "*");	salt_struct->e.fileIDLen = atoi(p);	salt_struct->e.fileID = (uint8_t *) malloc(salt_struct->e.fileIDLen);	p = strtok(NULL, "*");	for (i = 0; i < salt_struct->e.fileIDLen; i++)		salt_struct->e.fileID[i] =		    atoi16[ARCH_INDEX(p[i * 2])] * 16 +		    atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtok(NULL, "*");	salt_struct->e.encryptMetaData = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.work_with_user = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.have_userpassword = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.version_major = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.version_minor = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.length = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.permissions = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.revision = atoi(p);	p = strtok(NULL, "*");	salt_struct->e.version = atoi(p);	if (salt_struct->e.have_userpassword)		salt_struct->userpassword = (unsigned char *)strtok(NULL, "*");	free(keeptr);	/* try to initialize the cracking-engine */	if (!initPDFCrack(salt_struct)) {		fprintf(stderr, "Wrong userpassword, '%s'/n", salt_struct->userpassword);		exit(-1);	}	return (void *)salt_struct;}

static void *get_salt(char *ciphertext){	char *ctcopy = strdup(ciphertext);	char *keeptr = ctcopy;	char *p;	int i;	memset(&cs, 0, sizeof(cs));	ctcopy += TAG_LEN;	/* skip over "$oldoffice$" */	p = strtok(ctcopy, "*");	cs.type = atoi(p);	p = strtok(NULL, "*");	for (i = 0; i < 16; i++)		cs.salt[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtok(NULL, "*");	for (i = 0; i < 16; i++)		cs.verifier[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtok(NULL, "*");	if(cs.type < 3) {		for (i = 0; i < 16; i++)			cs.verifierHash[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16				+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	}	else {		for (i = 0; i < 20; i++)			cs.verifierHash[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16				+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	}	if ((p = strtok(NULL, "*"))) {		cs.has_mitm = 1;		for (i = 0; i < 5; i++)			cs.mitm[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16				+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	} else		cs.has_mitm = 0;	MEM_FREE(keeptr);	return (void *)&cs;}

static void *get_salt(char *ciphertext){    int i, length;    char *ctcopy = strdup(ciphertext);    char *keeptr = ctcopy, *p;    ctcopy += 9;	/* skip over "$office$*" */    cur_salt = mem_alloc_tiny(sizeof(struct custom_salt), MEM_ALIGN_WORD);    p = strtok(ctcopy, "*");    cur_salt->version = atoi(p);    p = strtok(NULL, "*");    cur_salt->verifierHashSize = atoi(p);    p = strtok(NULL, "*");    cur_salt->keySize = atoi(p);    p = strtok(NULL, "*");    cur_salt->saltSize = atoi(p);    if (cur_salt->saltSize > SALT_LENGTH) {        fprintf(stderr, "** error: salt longer than supported:/n%s/n", ciphertext);        cur_salt->saltSize = SALT_LENGTH; /* will not work, but protects us from segfault */    }    p = strtok(NULL, "*");    for (i = 0; i < cur_salt->saltSize; i++)        cur_salt->osalt[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16                             + atoi16[ARCH_INDEX(p[i * 2 + 1])];    p = strtok(NULL, "*");    for (i = 0; i < 16; i++)        cur_salt->encryptedVerifier[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16                                         + atoi16[ARCH_INDEX(p[i * 2 + 1])];    p = strtok(NULL, "*");    length = strlen(p) / 2;    for (i = 0; i < length; i++)        cur_salt->encryptedVerifierHash[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16                                             + atoi16[ARCH_INDEX(p[i * 2 + 1])];    MEM_FREE(keeptr);    return (void *)cur_salt;}

static void *get_salt(char *ciphertext){	char *ctcopy = strdup(ciphertext);	char *keeptr = ctcopy;	int i;	char *p;	static union {		struct custom_salt _cs;		ARCH_WORD_32 dummy;	} un;	struct custom_salt *cs = &(un._cs);	ctcopy += 4;	p = strtokm(ctcopy, "$");	cs->type = atoi(p);	p = strtokm(NULL, "$");	cs->NumCyclesPower = atoi(p);	p = strtokm(NULL, "$");	cs->SaltSize = atoi(p);	p = strtokm(NULL, "$"); /* salt */	p = strtokm(NULL, "$");	cs->ivSize = atoi(p);	p = strtokm(NULL, "$"); /* iv */	for (i = 0; i < cs->ivSize; i++)		cs->iv[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtokm(NULL, "$"); /* crc */	cs->crc = atou(p);	p = strtokm(NULL, "$");	cs->length = atoi(p);	p = strtokm(NULL, "$");	cs->unpacksize = atoi(p);	p = strtokm(NULL, "$"); /* crc */	for (i = 0; i < cs->length; i++)		cs->data[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	MEM_FREE(keeptr);	return (void *)cs;}

///code from historical JtR phpass patchstatic void pbinary(char *ciphertext, unsigned char *out){	int i, bidx = 0;	unsigned sixbits;	char *pos = &ciphertext[3 + 1 + 8];	memset(out, 0, BINARY_SIZE);	for (i = 0; i < 5; i++) {		sixbits = atoi64[ARCH_INDEX(*pos++)];		out[bidx] = sixbits;		sixbits = atoi64[ARCH_INDEX(*pos++)];		out[bidx++] |= (sixbits << 6);		sixbits >>= 2;		out[bidx] = sixbits;		sixbits = atoi64[ARCH_INDEX(*pos++)];		out[bidx++] |= (sixbits << 4);		sixbits >>= 4;		out[bidx] = sixbits;		sixbits = atoi64[ARCH_INDEX(*pos++)];		out[bidx++] |= (sixbits << 2);	}	sixbits = atoi64[ARCH_INDEX(*pos++)];	out[bidx] = sixbits;	sixbits = atoi64[ARCH_INDEX(*pos++)];	out[bidx] |= (sixbits << 6);}

static int valid(char *ciphertext, struct fmt_main *self){	char *pos, *start;	if (strncmp(ciphertext, "$1$", 3)) {		if (strncmp(ciphertext, "$apr1$", 6) &&		    strncmp(ciphertext, "{smd5}", 6))			return 0;		ciphertext += 3;	}	for (pos = &ciphertext[3]; *pos && *pos != '$'; pos++);	if (!*pos || pos < &ciphertext[3] || pos > &ciphertext[11]) return 0;	start = ++pos;	while (atoi64[ARCH_INDEX(*pos)] != 0x7F) pos++;	if (*pos || pos - start != CIPHERTEXT_LENGTH) return 0;	if (atoi64[ARCH_INDEX(*(pos - 1))] & 0x3C) return 0;	return 1;}

static int valid(char *ciphertext, struct fmt_main *pFmt){	uint8_t i, len = strlen(ciphertext), prefix = 0;	if (strncmp(ciphertext, md5_salt_prefix, strlen(md5_salt_prefix)) == 0)		prefix |= 1;	if (strncmp(ciphertext, apr1_salt_prefix,		strlen(apr1_salt_prefix)) == 0)		prefix |= 2;	if (prefix == 0)		return 0;	char *p = strrchr(ciphertext, '$');	for (i = p - ciphertext + 1; i < len; i++) {		uint8_t z = ARCH_INDEX(ciphertext[i]);		if (ARCH_INDEX(atoi64[z]) == 0x7f)			return 0;	}	if (len - (p - ciphertext + 1) != 22)		return 0;	return 1;};

static int valid(char* ciphertext, struct fmt_main *self){	unsigned int i;	if (strlen(ciphertext) != CIPHERTEXT_LENGTH)		return 0;	for (i = 0; i < CIPHERTEXT_LENGTH; i++)		if (atoi16[ARCH_INDEX(ciphertext[i])] > 15)			return 0;	return 1;}

static int valid(char *ciphertext, struct fmt_main *self){	char *p, *q;	if (strncmp(ciphertext, "$mysqlna$", 9))		return 0;	p = ciphertext + 9;	q = strstr(ciphertext, "*");	if(!q)		return 0;	if (q - p != CIPHERTEXT_LENGTH)		return 0;	while (atoi16[ARCH_INDEX(*p)] != 0x7F && p < q)		p++;	if (q - p != 0)		return 0;	if(strlen(p) < CIPHERTEXT_LENGTH)		return 0;	q = p + 1;	while (atoi16[ARCH_INDEX(*q)] != 0x7F)		q++;	return !*q && q - p - 1 == CIPHERTEXT_LENGTH;}

static int valid(char *ciphertext, struct fmt_main *self){	char *pos;	/* Require lowercase hex digits (assume ASCII) */	pos = ciphertext;	if (strncmp(pos, "$LION$", 6))		return 0;	pos += 6;	while (atoi16[ARCH_INDEX(*pos)] != 0x7F && (*pos <= '9' || *pos >= 'a'))		pos++;	return !*pos && pos - ciphertext == CIPHERTEXT_LENGTH+6;}

// Don't copy this code without realising it mimics bugs in the original code!// We are actually missing the last 16 bits with this implementation.static void *get_binary(char *ciphertext){	static ARCH_WORD_32 outbuf[BINARY_SIZE/4];	ARCH_WORD_32 value;	char *pos;	unsigned char *out = (unsigned char*)outbuf;	int i;	pos = strrchr(ciphertext, '$') + 1;	for (i = 0; i < 20; i++) {		TO_BINARY(i, i + 21, i + 42);	}	value = (ARCH_WORD_32)atoi64[ARCH_INDEX(pos[0])] |		((ARCH_WORD_32)atoi64[ARCH_INDEX(pos[1])] << 6) |		((ARCH_WORD_32)atoi64[ARCH_INDEX(pos[2])] << 12) |		((ARCH_WORD_32)atoi64[ARCH_INDEX(pos[3])] << 18);	out[20] = value >> 16;	out[41] = value >> 8;	return (void *)out;}

static int valid(char *ciphertext, struct fmt_main *self){    char *pos;    char lower[CIPHERTEXT_LENGTH - 16 + 1];    for (pos = ciphertext; atoi16[ARCH_INDEX(*pos)] != 0x7F; pos++);    if (!*pos && pos - ciphertext == CIPHERTEXT_LENGTH) {        strcpy(lower, &ciphertext[16]);        strlwr(lower);        if (strcmp(lower, LM_EMPTY))            return 2;        else            return 1;    }    if (strncmp(ciphertext, "$LM$", 4)) return 0;    for (pos = &ciphertext[4]; atoi16[ARCH_INDEX(*pos)] != 0x7F; pos++);    if (*pos || pos - ciphertext != 20) return 0;    return 1;}

static void *get_binary(char *ciphertext){	static unsigned char out[FULL_BINARY_SIZE];	char *p;	int i;	uint64_t *b;	p = ciphertext;	for (i = 0; i < sizeof(out); i++) {		out[i] =		    (atoi16[ARCH_INDEX(*p)] << 4) |		    atoi16[ARCH_INDEX(p[1])];		p += 2;	}	b = (uint64_t*)out;	for (i = 0; i < 8; i++) {		uint64_t t = SWAP64(b[i])-H[i];		b[i] = SWAP64(t);	}	return out;}

int sha512_common_valid_xsha(char *ciphertext, struct fmt_main *self){	char *pos;	/* Require lowercase hex digits (assume ASCII) */	pos = ciphertext;	if (strncmp(pos, XSHA512_FORMAT_TAG, XSHA512_TAG_LENGTH))		return 0;	pos += 6;	while (atoi16[ARCH_INDEX(*pos)] != 0x7F && (*pos <= '9' || *pos >= 'a'))		pos++;	return !*pos && pos - ciphertext == XSHA512_CIPHERTEXT_LENGTH+6;}

static int valid(char *ciphertext, struct fmt_main *self){	char *p, *q;	p = ciphertext;	if (!strncmp(p, FORMAT_TAG, TAG_LENGTH))		p += 8;	q = p;	while (atoi16[ARCH_INDEX(*q)] != 0x7F)		q++;	return !*q && q - p == CIPHERTEXT_LENGTH;}

/*   We're essentially using three salts, but we're going to pack it into a single blob for now.  Input:  $NETNTLMv2$USER_DOMAIN$_SERVER_CHALLENGE_$_NTLMv2_RESP_$_CLIENT_CHALLENGE_    Username: <=20    Domain: <=15    Server Challenge: 8 bytes    Client Challenge: ???  Output: Identity /0 Challenge Size /0 Server Challenge + Client Challenge*/static void *netntlmv2_get_salt(char *ciphertext){  static unsigned char binary_salt[SALT_SIZE_MAX];  int i, identity_length, challenge_size;  char *pos = NULL;  memset(binary_salt, 0, SALT_SIZE_MAX);  /* Calculate identity length; Set identity */  for (pos = ciphertext + 11; strncmp(pos, "$", 1) != 0; pos++);  identity_length = pos - (ciphertext + 11);  strncpy((char *)binary_salt, ciphertext + 11, identity_length);  /* Set server and client challenge size */  /* Skip: $NETNTLMv2$USER_DOMAIN$ */  ciphertext += 11 + identity_length + 1;  /* SERVER_CHALLENGE$NTLMV2_RESPONSE$CLIENT_CHALLENGE --> SERVER_CHALLENGECLIENT_CHALLENGE */  /* CIPHERTEXT == NTLMV2_RESPONSE (16 bytes / 32 characters) */  challenge_size = (strlen(ciphertext) - CIPHERTEXT_LENGTH - 2) / 2;  /* Set challenge size in response - 2 bytes - use NULL separators */  memset(binary_salt + identity_length + 1, (challenge_size & 0xFF00) >> 8, 1);   memset(binary_salt + identity_length + 2, challenge_size & 0x00FF, 1);     /* Set server challenge - add NULL separator after challenge size */  for (i = 0; i < SERVER_CHALL_LENGTH / 2; i++)    binary_salt[identity_length + 1 + 2 + 1 + i] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];    /* Set client challenge */  ciphertext += SERVER_CHALL_LENGTH + 1 + CIPHERTEXT_LENGTH + 1;   for (i = 0; i < strlen(ciphertext) / 2; ++i)    binary_salt[identity_length + 1 + 2 + 1 + SERVER_CHALL_LENGTH / 2 + i] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];  /* Return a concatenation of the server and client challenges and the identity value */   return (void*)binary_salt;}

static void *get_salt(char *ciphertext){	char *decoded_data;	int i;	char *ctcopy = strdup(ciphertext);	char *keeptr = ctcopy;	char *p;	static struct custom_salt cs;	PKCS12 *p12 = NULL;	BIO *bp;	ctcopy += 6;	/* skip over "$pfx$*" */	p = strtok(ctcopy, "*");	cs.len = atoi(p);	decoded_data = (char *) malloc(cs.len + 1);	p = strtok(NULL, "*");	for (i = 0; i < cs.len; i++)		decoded_data[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16 +    			atoi16[ARCH_INDEX(p[i * 2 + 1])];	decoded_data[cs.len] = 0;	/* load decoded data into OpenSSL structures */	bp = BIO_new(BIO_s_mem());	if (!bp) {		fprintf(stderr, "OpenSSL BIO allocation failure/n");		exit(-2);	}	BIO_write(bp, decoded_data, cs.len);	if(!(p12 = d2i_PKCS12_bio(bp, NULL))) {		perror("Unable to create PKCS12 object from bio/n");		exit(-3);	}	/* save custom_salt information */	memset(&cs, 0, sizeof(cs));	memcpy(&cs.pfx, p12, sizeof(PKCS12));	BIO_free(bp);	MEM_FREE(decoded_data);	MEM_FREE(keeptr);	return (void *) &cs;}

static void* get_salt(char *ciphertext){	static struct custom_salt cs;	char *ctcopy = strdup(ciphertext);	char *keeptr = ctcopy;	int i;	char *p;	ctcopy += 18;	p = strtok(ctcopy, "$"); /* iterations */	cs.num_iterations = atoi(p);	p = strtok(NULL, "$");   /* salt */	for (i = 0; i < OPENBSD_SOFTRAID_SALTLENGTH ; i++)		cs.salt[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtok(NULL, "$");   /* masked keys */	for (i = 0; i < OPENBSD_SOFTRAID_KEYLENGTH * OPENBSD_SOFTRAID_KEYS; i++)		cs.masked_keys[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];	MEM_FREE(keeptr);	return (void *)&cs;}

static int valid(char *ciphertext,struct fmt_main *pFmt){	int rounds;	char *pos;	if (strncmp(ciphertext, "$2a$", 4) &&	    strncmp(ciphertext, "$2x$", 4)) return 0;	if (ciphertext[4] < '0' || ciphertext[4] > '9') return 0;	if (ciphertext[5] < '0' || ciphertext[5] > '9') return 0;	rounds = atoi(ciphertext + 4);	if (rounds < 4 || rounds > 31) return 0;	if (ciphertext[6] != '$') return 0;	for (pos = &ciphertext[7]; atoi64[ARCH_INDEX(*pos)] != 0x7F; pos++);	if (*pos || pos - ciphertext != CIPHERTEXT_LENGTH) return 0;	if (opencl_BF_atoi64[ARCH_INDEX(*(pos - 1))] & 3) return 0;	if (opencl_BF_atoi64[ARCH_INDEX(ciphertext[28])] & 0xF) return 0;	return 1;}

static void *get_binary(char *ciphertext){	static ARCH_WORD out[6];	char base64[14];	int known_long;	int index;	unsigned int value;	out[0] = out[1] = 0;	strcpy(base64, AFS_SALT);	known_long = 0;	for (index = 0; index < 16; index += 2) {		value = atoi16[ARCH_INDEX(ciphertext[index + 4])] << 4;		value |= atoi16[ARCH_INDEX(ciphertext[index + 5])];		out[index >> 3] |= (value | 1) << ((index << 2) & 0x18);		if (atoi64[value >>= 1] == 0x7F)			known_long = 1;		else			base64[(index >> 1) + 2] = value;	}

static int valid(char *ciphertext, struct fmt_main *self){	char *pos;	if (!ciphertext[0] || !ciphertext[1]) return 0;	for (pos = &ciphertext[2]; atoi64[ARCH_INDEX(*pos)] != 0x7F; pos++);	if (*pos && *pos != ',') return 0;	if (atoi64[ARCH_INDEX(*(pos - 1))] & 3) return 0;	switch (pos - ciphertext) {	case CIPHERTEXT_LENGTH_1:		return 1;	case CIPHERTEXT_LENGTH_2:		if (atoi64[ARCH_INDEX(ciphertext[12])] & 3) return 0;		return 2;	default:		return 0;	}}

/* The mixing function: perturbs the first three rows of the matrix*/void MAYBE_INLINE lotus_mix (unsigned char *m1, unsigned char *m2){  int i, j;  unsigned char p1, p2;  unsigned char *t1, *t2;  p1 = p2 = 0x00;  for (i = 18; i > 0; i--)    {      t1 = m1;      t2 = m2;      for (j = 48; j > 0; )	{	  p1 = t1[0] ^= lotus_magic_table[ARCH_INDEX((j + p1) & 0xff)];	  p2 = t2[0] ^= lotus_magic_table[ARCH_INDEX((j-- + p2) & 0xff)];	  p1 = t1[1] ^= lotus_magic_table[ARCH_INDEX((j + p1) & 0xff)];	  p2 = t2[1] ^= lotus_magic_table[ARCH_INDEX((j-- + p2) & 0xff)];	  t1 += 2;	  t2 += 2;	}    }}

static int valid(char *ciphertext, struct fmt_main *self){	uint32_t i, count_log2;	int prefix=0;	if (strlen(ciphertext) != CIPHERTEXT_LENGTH)		return 0;	if (strncmp(ciphertext, "$P$", 3) == 0)		prefix=1;	if (strncmp(ciphertext, "$H$", 3) == 0)		prefix=1;	if(prefix==0) return 0;	for (i = 3; i < CIPHERTEXT_LENGTH; i++)		if (atoi64[ARCH_INDEX(ciphertext[i])] == 0x7F)			return 0;	count_log2 = atoi64[ARCH_INDEX(ciphertext[3])];	if (count_log2 < 7 || count_log2 > 31)		return 0;	return 1;};

static void *get_binary_256(char *ciphertext){    static union {        unsigned char c[32];        ARCH_WORD dummy;    } buf;    unsigned char *out = buf.c;    char *p;    int i;    if (!strncmp(ciphertext, FORMAT_TAG, TAG_LENGTH))        p = strrchr(ciphertext, '$') + 1;    else        p = ciphertext;    for (i = 0; i < 32; i++) {        out[i] =            (atoi16[ARCH_INDEX(*p)] << 4) |            atoi16[ARCH_INDEX(p[1])];        p += 2;    }    return out;}

static void ldr_init_issep(void){	char *pos;	if (issep_initialized) return;	memset(issep_map, 0, sizeof(issep_map));	memset(issep_map, 1, 33);	for (pos = issep; *pos; pos++)		issep_map[ARCH_INDEX(*pos)] = 1;	issep_initialized = 1;}