/* Generate HMAC-SHA1 intermediate Hash */ static void sa_hmac_sha1_get_pad(const u8 *key, u16 key_sz, u32 *ipad, u32 *opad) { u32 ws[SHA_WORKSPACE_WORDS]; u8 k_ipad[SHA_MESSAGE_BYTES]; u8 k_opad[SHA_MESSAGE_BYTES]; int i; for (i = 0; i < key_sz; i++) { k_ipad[i] = key[i] ^ 0x36; k_opad[i] = key[i] ^ 0x5c; } /* Instead of XOR with 0 */ for (; i < SHA_MESSAGE_BYTES; i++) { k_ipad[i] = 0x36; k_opad[i] = 0x5c; } /* SHA-1 on k_ipad */ sha_init(ipad); sha_transform(ipad, k_ipad, ws); for (i = 0; i < SHA_DIGEST_WORDS; i++) ipad[i] = cpu_to_be32(ipad[i]); /* SHA-1 on k_opad */ sha_init(opad); sha_transform(opad, k_opad, ws); for (i = 0; i < SHA_DIGEST_WORDS; i++) opad[i] = cpu_to_be32(opad[i]); }
int NET_CookieHash(netadr_t *from){ uint32_t digest[5]; uint32_t workspace[80]; char data[64]; int i; if(from->type == NA_IP){ for(i = 0; i < 4; i++) data[i] = from->ip[i]; *((unsigned short*)&data[4]) = from->port; Com_Memcpy(&data[6], net_cookieSecret, sizeof(net_cookieSecret)); }else if(from->type == NA_IP6){ for(i = 0; i < 16; i++) data[i] = from->ip[i]; *((unsigned short*)&data[16]) = from->port; Com_Memcpy(&data[18], net_cookieSecret, sizeof(net_cookieSecret) - 46); }else return 0; sha_init(digest); sha_transform(digest, data, workspace); return digest[0]; }
void test_run() { sha_init(&sha_info); for(int n = 0; n < 4; ++n) { sha_update(&sha_info, data + 4 * n, 256); } sha_final(&sha_info); }
/* * Create a DiscID based on the TOC data found in the DiscId object. * The DiscID is placed in the provided string buffer. */ static void create_disc_id(mb_disc_private *d, char buf[]) { SHA_INFO sha; unsigned char digest[20], *base64; unsigned long size; char tmp[17]; /* for 8 hex digits (16 to avoid trouble) */ int i; assert( d != NULL ); sha_init(&sha); sprintf(tmp, "%02X", d->first_track_num); sha_update(&sha, (unsigned char *) tmp, strlen(tmp)); sprintf(tmp, "%02X", d->last_track_num); sha_update(&sha, (unsigned char *) tmp, strlen(tmp)); for (i = 0; i < 100; i++) { sprintf(tmp, "%08X", d->track_offsets[i]); sha_update(&sha, (unsigned char *) tmp, strlen(tmp)); } sha_final(digest, &sha); base64 = rfc822_binary(digest, sizeof(digest), &size); memcpy(buf, base64, size); buf[size] = '\0'; free(base64); }
VOID NextBitLoc( ULONG *resx, ULONG *resy, UWORD width, UWORD height ) { ULONG x, y, hash; SHA_INFO sha = {0}; y = counter / width; x = counter % width; // First iteration sha_init(&sha); sha_update( &sha, key, SHA_DIGESTSIZE ); sha_update( &sha, (UBYTE *)&x, sizeof(x) ); sha_final( &sha ); D(sha_print( &sha )); hash = (sha.digest[0] & 0x7fffffff); // Lose the sign y = (y+hash) % height; // Second iteration sha_init(&sha); sha_update( &sha, key, SHA_DIGESTSIZE ); sha_update( &sha, (UBYTE *)&y, sizeof(y) ); sha_final( &sha ); D(sha_print( &sha )); hash = (sha.digest[0] & 0x7fffffff); // Lose the sign x = (x+hash) % width; // Third iteration sha_init(&sha); sha_update( &sha, key, SHA_DIGESTSIZE ); sha_update( &sha, (UBYTE *)&x, sizeof(x) ); sha_final( &sha ); D(sha_print( &sha )); hash = (sha.digest[0] & 0x7fffffff); // Lose the sign y = (y+hash) % height; *resx = x; *resy = y; ++counter; }
char *shahash(const char *str) { char read_buffer[65]; //int read_buffer[64]; int c=1, i; INT64 length=0; int strsz; static char final[40]; int *hashval; hashval = (int *)malloc(20); sha_init(hashval); strsz = strlen(str); if(strsz == 0) { memset(read_buffer, 0, 65); read_buffer[0] = 0x80; sha_hash((int *)read_buffer, hashval); } while (strsz>0) { memset(read_buffer, 0, 65); strncpy((char*)read_buffer, str, 64); c = strlen((char *)read_buffer); length+=c; strsz-=c; if (strsz<=0) { length<<=3; read_buffer[c]=(char)0x80; for (i=c+1; i<64; i++) read_buffer[i]=0; if (c>55) { /* we need to do an entire new block */ sha_hash((int *)read_buffer, hashval); for (i=0; i<14; i++) ((int*)read_buffer)[i]=0; } #ifndef WORDS_BIGENDIAN for (i=0; i<8; i++) { read_buffer[56+i]=(char)(length>>(56-(i*8))) & 0xff; } #else memcpy(read_buffer+56, &length, 8); #endif } sha_hash((int *)read_buffer, hashval); str+=64; }
PERROR MakeKeyMaterial( FRAME *frame, UBYTE *passphrase, struct PPTBase *PPTBase ) { ROWPTR cp, tmprow; WORD row; struct ExecBase *SysBase = PPTBase->lb_Sys; SHA_INFO sha = {0}; PERROR res = PERR_OK; sha_init( &sha ); InitProgress(frame,"Building key...", 0, frame->pix->height ); /* * First, use the passphrase for the key. */ if( strlen(passphrase) > 0 ) sha_update( &sha, passphrase, strlen(passphrase) ); if( tmprow = AllocVec( frame->pix->bytes_per_row, 0L ) ) { for( row = 0; row < frame->pix->height; row++ ) { WORD col; cp = GetPixelRow( frame, row ); if( Progress( frame, row ) ) { res = PERR_BREAK; break; } for( col = 0; col < frame->pix->bytes_per_row; col++ ) { /* Use only significant bytes */ tmprow[col] = cp[col] & 0xFE; } sha_update( &sha, tmprow, frame->pix->bytes_per_row ); } // Use the passphrase again (why?) if( strlen(passphrase) > 0 ) sha_update( &sha, passphrase, strlen(passphrase) ); FinishProgress( frame ); sha_final( &sha ); memcpy( key, &sha.digest[0], SHA_DIGESTSIZE ); D(sha_print( &sha ) ); FreeVec( tmprow ); } else { SetErrorCode( frame, PERR_OUTOFMEMORY ); res = PERR_OUTOFMEMORY; } return res; }
int ctr_nand_crypto_interface_initialize(ctr_nand_crypto_interface *crypto_io, uint8_t keySlot, ctr_nand_crypto_type crypto_type, ctr_io_interface *lower_io) { crypto_io->base = nand_crypto_base; //Get the nonces for CTRNAND and TWL decryption uint32_t mode; uint32_t NandCid[4]; alignas(4) uint8_t shasum[32]; sdmmc_get_cid(true, NandCid); uint32_t ctr[4]; switch (crypto_type) { case NAND_CTR: check_and_do_n3ds_init(); sha_init(SHA256_MODE); sha_update((uint8_t*)NandCid, 16); sha_get(shasum); memcpy(ctr, shasum, 16); mode = AES_CNT_CTRNAND_MODE; break; case NAND_TWL: check_and_do_twl_init(); sha_init(SHA1_MODE); sha_update((uint8_t*)NandCid, 16); sha_get(shasum); for(uint32_t i = 0; i < 16u; i++) // little endian and reversed order { ((uint8_t*)ctr)[i] = shasum[15-i]; } mode = AES_CNT_TWLNAND_MODE; break; default: return 1; //Unknown type } ctr_crypto_interface_initialize(&crypto_io->crypto_io, keySlot, mode, CTR_CRYPTO_ENCRYPTED, CRYPTO_CTR, (uint8_t*)ctr, lower_io); return 0; }
CK_RV digest_mgr_init( STDLL_TokData_t *tokdata, SESSION *sess, DIGEST_CONTEXT *ctx, CK_MECHANISM *mech ) { CK_RV rc = CKR_OK; CK_BYTE * ptr = NULL; if (!sess || !ctx){ TRACE_ERROR("Invalid function arguments.\n"); return CKR_FUNCTION_FAILED; } if (ctx->active != FALSE){ TRACE_ERROR("%s\n", ock_err(ERR_OPERATION_ACTIVE)); return CKR_OPERATION_ACTIVE; } // is the mechanism supported? is the parameter present if required? // switch (mech->mechanism) { case CKM_SHA_1: case CKM_SHA256: case CKM_SHA384: case CKM_SHA512: { if (mech->ulParameterLen != 0){ TRACE_ERROR("%s\n", ock_err(ERR_MECHANISM_PARAM_INVALID)); return CKR_MECHANISM_PARAM_INVALID; } ctx->context = NULL; rc = sha_init(tokdata, sess, ctx, mech); if (rc != CKR_OK) { digest_mgr_cleanup(ctx); // to de-initialize context above TRACE_ERROR("Failed to init sha context.\n"); return rc; } } break; case CKM_MD2: { if (mech->ulParameterLen != 0){ TRACE_ERROR("%s\n", ock_err(ERR_MECHANISM_PARAM_INVALID)); return CKR_MECHANISM_PARAM_INVALID; } ctx->context_len = sizeof(MD2_CONTEXT); ctx->context = (CK_BYTE *)malloc(sizeof(MD2_CONTEXT)); if (!ctx->context){ digest_mgr_cleanup(ctx); // to de-initialize context above TRACE_ERROR("%s\n", ock_err(ERR_HOST_MEMORY)); return CKR_HOST_MEMORY; } memset( ctx->context, 0x0, sizeof(MD2_CONTEXT) ); } break; case CKM_MD5: { if (mech->ulParameterLen != 0){ TRACE_ERROR("%s\n", ock_err(ERR_MECHANISM_PARAM_INVALID)); return CKR_MECHANISM_PARAM_INVALID; } ctx->context_len = sizeof(MD5_CONTEXT); ctx->context = (CK_BYTE *)malloc(sizeof(MD5_CONTEXT)); if (!ctx->context){ digest_mgr_cleanup(ctx); // to de-initialize context above TRACE_ERROR("%s\n", ock_err(ERR_HOST_MEMORY)); return CKR_HOST_MEMORY; } ckm_md5_init( tokdata, (MD5_CONTEXT *)ctx->context ); } break; default: TRACE_ERROR("%s\n", ock_err(ERR_MECHANISM_INVALID)); return CKR_MECHANISM_INVALID; } if (mech->ulParameterLen > 0) { ptr = (CK_BYTE *)malloc(mech->ulParameterLen); if (!ptr){ digest_mgr_cleanup(ctx); // to de-initialize context above TRACE_ERROR("%s\n", ock_err(ERR_HOST_MEMORY)); return CKR_HOST_MEMORY; } memcpy( ptr, mech->pParameter, mech->ulParameterLen ); } ctx->mech.ulParameterLen = mech->ulParameterLen; ctx->mech.mechanism = mech->mechanism; ctx->mech.pParameter = ptr; ctx->multi = FALSE; ctx->active = TRUE; return CKR_OK; }
char *par_mktmpdir ( char **argv ) { int i; const char *tmpdir = NULL; const char *key = NULL , *val = NULL; /* NOTE: all arrays below are NULL terminated */ const char *temp_dirs[] = { P_tmpdir, #ifdef WIN32 "C:\\TEMP", #endif ".", NULL }; const char *temp_keys[] = { "PAR_TMPDIR", "TMPDIR", "TEMPDIR", "TEMP", "TMP", NULL }; const char *user_keys[] = { "USER", "USERNAME", NULL }; const char *subdirbuf_prefix = "par-"; const char *subdirbuf_suffix = ""; char *progname = NULL, *username = NULL; char *stmpdir = NULL, *top_tmpdir = NULL; int f, j, k, stmp_len = 0; char sha1[41]; SHA_INFO sha_info; unsigned char buf[32768]; unsigned char sha_data[20]; if ( (val = par_getenv(PAR_TEMP)) && strlen(val) ) { par_setup_libpath(val); return strdup(val); } #ifdef WIN32 { DWORD buflen = MAXPATHLEN; username = malloc(MAXPATHLEN); GetUserName((LPTSTR)username, &buflen); // FIXME this is uncondifionally overwritten below - WTF? } #endif /* Determine username */ username = get_username_from_getpwuid(); if ( !username ) { /* fall back to env vars */ for ( i = 0 ; username == NULL && (key = user_keys[i]); i++) { if ( (val = par_getenv(key)) && strlen(val) ) username = strdup(val); } } if ( username == NULL ) username = "******"; /* sanitize username: encode all bytes as 2 hex digits */ { char *hexname = malloc(2 * strlen(username) + 1); char *u, *h; for ( u = username, h = hexname ; *u != '\0' ; u++, h += 2) sprintf(h, "%02x", *(unsigned char*)u); username = hexname; } /* Try temp environment variables */ for ( i = 0 ; tmpdir == NULL && (key = temp_keys[i]); i++ ) { if ( (val = par_getenv(key)) && strlen(val) && isWritableDir(val) ) { tmpdir = strdup(val); break; } } #ifdef WIN32 /* Try the windows temp directory */ if ( tmpdir == NULL && (val = par_getenv("WinDir")) && strlen(val) ) { char* buf = malloc(strlen(val) + 5 + 1); sprintf(buf, "%s\\temp", val); if (isWritableDir(buf)) { tmpdir = buf; } else { free(buf); } } #endif /* Try default locations */ for ( i = 0 ; tmpdir == NULL && (val = temp_dirs[i]) && strlen(val) ; i++ ) { if ( isWritableDir(val) ) { tmpdir = strdup(val); } } /* "$TEMP/par-$USER" */ stmp_len = strlen(tmpdir) + strlen(subdirbuf_prefix) + strlen(username) + strlen(subdirbuf_suffix) + 1024; /* stmpdir is what we are going to return; top_tmpdir is the top $TEMP/par-$USER, needed to build stmpdir. NOTE: We need 2 buffers because snprintf() can't write to a buffer it is also reading from. */ top_tmpdir = malloc( stmp_len ); sprintf(top_tmpdir, "%s%s%s%s", tmpdir, dir_sep, subdirbuf_prefix, username); #ifdef WIN32 _mkdir(top_tmpdir); /* FIXME bail if error (other than EEXIST) */ #else { if (mkdir(top_tmpdir, 0700) == -1 && errno != EEXIST) { fprintf(stderr, "%s: creation of private subdirectory %s failed (errno=%i)\n", argv[0], top_tmpdir, errno); return NULL; } if (!isSafeDir(top_tmpdir)) { fprintf(stderr, "%s: private subdirectory %s is unsafe (please remove it and retry your operation)\n", argv[0], top_tmpdir); return NULL; } } #endif stmpdir = malloc( stmp_len ); /* Doesn't really work - XXX */ val = par_getenv( "PATH" ); if (val != NULL) progname = par_findprog(argv[0], strdup(val)); if (progname == NULL) progname = argv[0]; /* If invoked as "/usr/bin/parl foo.par myscript.pl" then progname should * be ".../parl", and we don't want to base our checksum on that, but * rather on "foo.par". */ { #ifdef WIN32 #define STREQ(a,b) (strcasecmp(a,b) == 0) #else #define STREQ(a,b) (strcmp(a,b) == 0) #endif int prog_len = strlen(progname); int parl_len = strlen(PARL_EXE); if (prog_len >= parl_len && STREQ(progname + prog_len - parl_len, PARL_EXE) && (prog_len == parl_len || progname[prog_len - parl_len - 1] == dir_sep[0]) && argv[1] && strlen(argv[1]) >= 4 && STREQ(argv[1] + strlen(argv[1]) - 4, ".par")) progname = argv[1]; #undef STREQ } if ( !par_env_clean() && (f = open( progname, O_RDONLY | OPEN_O_BINARY ))) { lseek(f, -18, 2); read(f, buf, 6); if(buf[0] == 0 && buf[1] == 'C' && buf[2] == 'A' && buf[3] == 'C' && buf[4] == 'H' && buf[5] == 'E') { /* pre-computed cache_name in this file */ /* "$TEMP/par-$USER/cache-$cache_name" */ lseek(f, -58, 2); read(f, buf, 41); sprintf( stmpdir, "%s%scache-%s%s", top_tmpdir, dir_sep, buf, subdirbuf_suffix ); } else { /* "$TEMP/par-$USER/cache-$SHA1" */ lseek(f, 0, 0); sha_init( &sha_info ); while( ( j = read( f, buf, sizeof( buf ) ) ) > 0 ) { sha_update( &sha_info, buf, j ); } close( f ); sha_final( sha_data, &sha_info ); for( k = 0; k < 20; k++ ) { sprintf( sha1+k*2, "%02x", sha_data[k] ); } sha1[40] = '\0'; sprintf( stmpdir, "%s%scache-%s%s", top_tmpdir, dir_sep, sha1, subdirbuf_suffix ); } } else { int i = 0; /* "$TEMP/par-$USER/temp-$PID" */ par_setenv("PAR_CLEAN", "1"); sprintf( stmpdir, "%s%stemp-%u%s", top_tmpdir, dir_sep, getpid(), subdirbuf_suffix ); /* Ensure we pick an unused directory each time. If the directory already exists when we try to create it, bump a counter and try "$TEMP/par-$USER/temp-$PID-$i". This will guard against cases where a prior invocation crashed leaving garbage in a temp directory that might interfere. */ while (my_mkdir(stmpdir, 0700) == -1 && errno == EEXIST) { sprintf( stmpdir, "%s%stemp-%u-%u%s", top_tmpdir, dir_sep, getpid(), ++i, subdirbuf_suffix ); } } free(top_tmpdir); /* set dynamic loading path */ par_setenv(PAR_TEMP, stmpdir); par_setup_libpath( stmpdir ); return stmpdir; }
nyx_error_t security_init_hash(nyx_device_handle_t d, const char *hash_algo) { return sha_init(hash_algo); }
/* * hash the password */ void do_sha_hash(int *hashval, int *pw) { sha_init(hashval); sha_hash(pw, hashval); }