// . have we added the meta list to our rdbs yet? // . can not delete the actual meta list from syncdb until so bool Syncdb::canDeleteMetaList ( uint32_t sid , uint64_t zid ) { // make the "c" key to see if we still need to add the meta list key128_t k = makeKey(0,0,1,0,0,sid,zid,1); // get it long nn = m_qt.getNode ( 0 , (char *)&k ); // if "c" key is there, that means we need to add to our rdb still // so we can not delete it yet! if ( nn >= 0 ) return false; // get group we are in Host *group = g_hostdb.getMyShard(); // . if we need to send some requests still can not delete // . number hosts in group long nh = g_hostdb.getNumHostsPerShard(); // loop over our twins for ( long i = 0 ; i < nh ; i++ ) { // get host Host *h = &group[i]; // skip if us if ( h == g_hostdb.m_myHost ) continue; // check the need to send req key now. the "a" key. k = makeKey(1,0,0,0,h->m_hostId,sid,zid,1); // get it nn = m_qt.getNode ( 0 , (char *)&k ); // if there, we cannot delete it yet if ( nn >= 0 ) return false; // check the recv key now. the "b" key. k = makeKey(0,1,0,0,h->m_hostId,sid,zid,1); // get it nn = m_qt.getNode ( 0 , (char *)&k ); // if there, we cannot delete it yet if ( nn >= 0 ) return false; } // i guess we can delete it, all keys are gone return true; }
int lineReader(char *line, HashTable *numbers){ int key; int x; if(line[0] == 'i' || line[0] == 'I'){ key = makeKey(&line[2]); x = insertValue(key, numbers); if(x == -1){ printf("duplicate\n"); return 0; }else{ printf("inserted\n"); return 0; } }else if(line[0] == 's' || line[0] == 'S'){ key = makeKey(&line[2]); x = searchValue(key, numbers); if(x == -1){ printf("absent\n"); return 0; }else{ printf("present\n"); return 0; } }else{ printf("error\n"); return 0; } }
std::list<ModelPair> LocationModelManager::collectModelPairs(ModelId mid) { std::list<ModelPair> keys; LocationModel *model = at(mid); if(nullptr != model) { for(AgentId const aid : model->sources()) { Agent *agent = mLevel->agentMan()->getAgent(aid); if(nullptr == agent) continue; keys.push_back(makeKey(agent->locationModelId(), mid)); keys.push_back(makeKey(mid, agent->locationModelId())); } for(AgentId const aid : model->destinations()) { Agent *agent = mLevel->agentMan()->getAgent(aid); if(nullptr == agent) continue; keys.push_back(makeKey(agent->locationModelId(), mid)); keys.push_back(makeKey(mid, agent->locationModelId())); } } return keys; }
int Core::pullHost(string hostname, string &ip_address, int& port, string &username, string &password, string &enable_password) { map<string,hosts_t>::iterator it; std::string key; key = makeKey(hostname, 22); it = hosts.find(key); if (it == hosts.end()) { return -1; } hosts_t * tmp_host = &(*it).second; ip_address = tmp_host->ip_address; port = tmp_host->port; username = tmp_host->username; password = tmp_host->password; if (!cisco_mode) return 0; key = makeKey(hostname, 0); it = hosts.find(key); if (it == hosts.end()) { return 0; // may be we don't need enable password } tmp_host = &(*it).second; enable_password = tmp_host->password; return 0; }
static void rijndaelVKKAT(FILE * fp, int keyLength) { int i, j, r; BYTE block[4 * 4]; BYTE keyMaterial[320]; BYTE byteVal = (BYTE) '8'; keyInstance keyInst; cipherInstance cipherInst; #ifdef TRACE_KAT_MCT printf("Executing Variable-Key KAT (key %d): ", keyLength); fflush(stdout); #endif /* ?TRACE_KAT_MCT */ fprintf(fp, "\n" "==========\n" "\n" "KEYSIZE=%d\n" "\n", keyLength); fflush(fp); memset(block, 0, 16); blockPrint(fp, block, "PT"); memset(keyMaterial, 0, sizeof(keyMaterial)); memset(keyMaterial, '0', keyLength / 4); for (i = 0; i < keyLength; i++) { keyMaterial[i / 4] = byteVal; /* set only the i-th bit of the i-th test key */ r = makeKey(&keyInst, DIR_ENCRYPT, keyLength, keyMaterial); if (TRUE != r) { fprintf(stderr, "makeKey error %d\n", r); exit(-1); } fprintf(fp, "\nI=%d\n", i + 1); fprintf(fp, "KEY=%s\n", keyMaterial); memset(block, 0, 16); r = cipherInit(&cipherInst, MODE_ECB, NULL); if (TRUE != r) { fprintf(stderr, "cipherInit error %d\n", r); exit(-1); } r = blockEncrypt(&cipherInst, &keyInst, block, 128, block); if (128 != r) { fprintf(stderr, "blockEncrypt error %d\n", r); exit(-1); } blockPrint(fp, block, "CT"); /* now check decryption: */ makeKey(&keyInst, DIR_DECRYPT, keyLength, keyMaterial); blockDecrypt(&cipherInst, &keyInst, block, 128, block); for (j = 0; j < 16; j++) { assert(block[j] == 0); } /* undo changes for the next iteration: */ keyMaterial[i / 4] = (BYTE) '0'; byteVal = (byteVal == '8') ? '4' : (byteVal == '4') ? '2' : (byteVal == '2') ? '1' : /* (byteVal == '1') */ '8'; } assert(byteVal == (BYTE) '8'); #ifdef TRACE_KAT_MCT printf(" done.\n"); #endif /* ?TRACE_KAT_MCT */ } /* rijndaelVKKAT */
void PhraseLVI::setText( int column, const QString& text ) { if ( column == SourceTextShown ) { sourceTextKey = makeKey( text ); } else if ( column == TargetTextShown ) { targetTextKey = makeKey( text ); } QListViewItem::setText( column, text ); }
static void rijndaelIVKAT (FILE *fp, int keyLength) { int i; BYTE pt[4*4], ct[4*4]; BYTE keyMaterial[320]; keyInstance keyInst; cipherInstance cipherInst; char format[10]; #ifdef TRACE_KAT_MCT printf ("Executing Intermediate value KAT (key %d): ", keyLength); fflush (stdout); #endif /* ?TRACE_KAT_MCT */ fprintf(fp, "\n" "==========\n" "\n" "KEYSIZE=%d\n", keyLength); fflush(fp); memset(keyMaterial, 0, sizeof (keyMaterial)); for (i = 0; i < keyLength/8; i++) { sprintf(&keyMaterial[2*i], "%02X", i); } fprintf(fp, "KEY=%s\n", keyMaterial); for (i = 0; i < 16; i++) { pt[i] = i; } fprintf(fp, "\nIntermediate Ciphertext Values (Encryption)\n\n"); makeKey(&keyInst, DIR_ENCRYPT, keyLength, keyMaterial); blockPrint(fp, pt, "PT"); cipherInit(&cipherInst, MODE_ECB, NULL); for(i = 1; i < keyInst.Nr; i++) { cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, i); sprintf(format, "CT%d", i); blockPrint(fp, ct, format); } cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, keyInst.Nr); blockPrint(fp, ct, "CT"); fprintf(fp, "\nIntermediate Ciphertext Values (Decryption)\n\n"); makeKey(&keyInst, DIR_DECRYPT, keyLength, keyMaterial); blockPrint(fp, ct, "CT"); cipherInit(&cipherInst, MODE_ECB, NULL); for(i = 1; i < keyInst.Nr; i++) { cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, i); sprintf(format, "PT%d", i); blockPrint(fp, pt, format); } cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, keyInst.Nr); blockPrint(fp, pt, "PT"); #ifdef TRACE_KAT_MCT printf(" done.\n"); #endif }
// . ***** META LIST DELETE LOOP ***** // . scan for meta lists to remove from syncdb // . check every D KEY // . must NOT have any "need to send request" keys (a bit set) // . must NOT have any "need to recv request" keys (b bit set) // . must NOT have our "need to add" key (c bit set) void Syncdb::loop3 ( ) { // . loop over the meta lists we need to delete // . these are "d" keys // . use a "tid" of 0 key128_t sk = makeKey ( 0,0,0,1,0,0,0,0 ); key128_t ek = makeKey ( 0,0,0,1,0,0xffffffff,0xffffffffffffffffLL,1 ); // get the first node in sequence, if any long nn = m_qt.getNextNode ( 0 , (char *)&sk ); // do the loop for ( ; nn >= 0 ; nn = m_qt.getNextNode ( nn ) ) { // breathe QUICKPOLL ( MAX_NICENESS ); // get key key128_t k = *(key128_t *)m_qt.getKey ( nn ); // stop when we hit the end if ( k > ek ) break; // get zid uint64_t zid = getZid ( &k ); // get sid uint32_t sid = getSid ( &k ); // have we sent/recvd all checkoff requests required? have // we added the meta list? if so, we can nuke it from syncdb if ( ! canDeleteMetaList ( sid, zid ) ) { // no use banging away at this sid any more since we // are missing another action for this one sid++; // find the key of the FIRST meta list we need to add // for this new senderId, "sid" key128_t nk = makeKey ( 0,0,0,1,0,sid,0,0 ); // undo the m_qt.getNextNode(nn) we call in for loop nn = m_qt.getPrevNode ( 0 , (char *)&nk ); // sanity check if ( nn < 0 ) { char *xx=NULL;*xx=0; } // get next key from this new sid continue; } // . make the negative key for syncdb // . it just uses a negative "c" key, with a tid of 0 key128_t dk = makeKey ( 0,0,1,0,0,sid,zid,0); // . add it to syncdb to signifiy a delete // . this returns false and sets g_errno on error if(!m_rdb.addRecord((collnum_t)0,(char *)&dk,NULL,0, MAX_NICENESS)) return; // delete it from quick tree now that we added the negative // key successfully to syncdb long dn = m_qt.getNode ( 0, (char *)&k ); // must be there! if ( ! dn ) { char *xx=NULL;*xx=0; } // nuke it m_qt.deleteNode ( dn , true ); } // . success // . do not recall until big loop completes a round m_calledLoop3 = true; }
void Syncdb::loopReset() { m_outstanding = false; // reset flags m_calledLoop1 = false; m_calledLoop2 = false; m_calledLoop3 = false; m_calledLoop4 = false; m_calledLoop5 = false; m_syncKey = makeKey(0,1,0,0,0,0,0,0); m_addCount = 0; // if done calling loop5(), reset this m_nextk = makeKey ( 1,0,0,0,0,0,0,0 ); }
void AES_SetKey(AES_Struct *aes, const unsigned char *key, unsigned int key_len) { unsigned char hexkey[64]; if (key_len != 16 && key_len != 24 && key_len != 32) { fprintf(stderr, "AES_SetKey: key must be 128, 192 or 256 bits.\n"); abort(); } str_to_hex(key, key_len, hexkey); makeKey(&aes->encrypt_key, DIR_ENCRYPT, key_len * 8, (char *) hexkey); makeKey(&aes->decrypt_key, DIR_DECRYPT, key_len * 8, (char *) hexkey); aes->key_gen = 1; }
void mgcStatusTblAdd(struct mgcStatusTbl *mst, unsigned imageId, struct mgcStatusType *status, char *acc, char *organism, char* geneName) /* Add an entry to the table. acc maybe NULL */ { struct mgcStatus *ms; lmAllocVar(mst->lm, ms); ms->imageId = imageId; ms->status = status; if ((acc != NULL) && (acc[0] != '\0')) ms->acc = lmCloneString(mst->lm, acc); else ms->acc = NULL; safef(ms->organism, sizeof(ms->organism), "%s", organism); if ((geneName != NULL) && (geneName[0] != '\0')) ms->geneName = lmCloneString(mst->lm, geneName); else ms->geneName = NULL; if (mst->imageIdHash != NULL) { char key[64]; makeKey(imageId, key); hashAdd(mst->imageIdHash, key, ms); } if ((mst->accHash != NULL) && (acc != NULL)) hashAdd(mst->accHash, ms->acc, ms); }
BOOL SetRegistryDWordArray(HKEY root, const CString & var, CDWordArray & data) { CString path; path.LoadString(IDS_PROGRAM_ROOT); CString name; makePath(path, var, name); HKEY key; LONG result = makeKey(root, path, &key); if(result != ERROR_SUCCESS) { /* save it */ ::SetLastError((DWORD)result); return FALSE; } /* save it */ result = ::RegSetValueEx(key, name, 0, REG_BINARY, (LPBYTE)&(data[0]), data.GetSize() * sizeof(DWORD)); ::RegCloseKey(key); if(result != ERROR_SUCCESS) ::SetLastError((DWORD)result); return result == ERROR_SUCCESS; }
// . have we sent all the checkoff requests (and got replies) for this sid/zid? // . we cannot add a meta list until we have bool Syncdb::sentAllCheckoffRequests ( uint32_t sid , uint64_t zid ) { // get group we are in Host *group = g_hostdb.getMyShard(); // number hosts in group long nh = g_hostdb.getNumHostsPerShard(); // loop over our twins for ( long i = 0 ; i < nh ; i++ ) { // get host Host *h = &group[i]; // skip if us if ( h == g_hostdb.m_myHost ) continue; // skip if dead if ( g_hostdb.isDead ( h ) ) continue; // make the key key128_t k = makeKey(1,0,0,0,h->m_hostId,sid,zid,1); // get it long nn = m_qt.getNode ( 0 , (char *)&k ); // if it is there, that means we have yet to get a reply // for this checkoff request! because once we get a successful // reply for it, we delete it from quick tree if ( nn >= 0 ) return false; } // i guess we are good to go! return true; }
// ======================================================= // ======================================================= int INIReader::valueHandler(void* user, const char* section, const char* name, const char* value) { INIReader* reader = (INIReader*)user; reader->_values[makeKey(section, name)] = value; return 1; }
void testObj::test<3>(void) { const char text[] = "alice has a cypher"; assert( (sizeof(text) < Aes256::keySize()) && "test text is too long" ); // copy text to vector Algo::Data data; for(const char* str=text; *str!=0; ++str) data.push_back(*str); // encrypt api_.encrypt(data); // check if it is not plaintext { std::string tmp; copy( data.begin(), data.end(), std::back_insert_iterator<std::string>(tmp) ); ensure("plaintext detected!", tmp.c_str()!=std::string(text) ); // NOTE: tmp has trailing '0' that makes != fail to detect difference } // decrypt Aes256 dec( makeKey() ); dec.decrypt(data); // check decrypted message { std::string tmp; copy( data.begin(), data.end(), std::back_insert_iterator<std::string>(tmp) ); ensure_equals("decryption error", tmp.c_str(), std::string(text) ); // NOTE: tmp has trailing '0' that makes != fail to detect difference } }
////////////////////////////////////////////////////////////////////// // Checks if the goals given as parameter have not already been //proven unsatisfiable ////////////////////////////////////////////////////////////////////// bool MemoizationLevel::isNoGood(IntVector &ivGoals) { string sKey=makeKey(ivGoals); bool bRes = (ivmNoGoods.find(sKey) != ivmNoGoods.end()); return bRes; }
void SensorArray::addSensor(unsigned thePortId, unsigned theControllerId, unsigned theBitNumber, const asl::Vector2i & theCoordinate) { unsigned key = makeKey(thePortId, theControllerId, theBitNumber); _mySensorMap[key] = theCoordinate; }
void getRooms(AbstractRoomVisitor &stream, ParseEvent &event_) override { const auto &event = event_; assert(event.size() == 3); const MaskFlags mask = getKeyMask(event); if (!isMatchedByTree(mask)) return; auto tmp = event.clone(); tmp.reset(); auto key = makeKey(tmp, mask, m_useVerboseKeys); Secondary &thislevel = m_secondary[mask]; SV &homes = thislevel[key]; for (const PV &home : homes) { if (home != nullptr) { home->forEach(stream); } } return; }
void * Win32SharedMemory::open(size_t key, size_t size) { handle_ = OpenFileMapping(FILE_MAP_ALL_ACCESS, // read/write access FALSE, // do not inherit the name makeKey(key).c_str()); // name of mapping object if(handle_ == NULL) { fprintf(stderr, TEXT("Could not open file mapping object (%d).\n"), GetLastError()); return NULL; } void * mem = MapViewOfFile(handle_, // handle to map object FILE_MAP_ALL_ACCESS, // read/write permission 0, 0, size); if(mem == NULL) { fprintf(stderr, "Could not map view of file (%d).\n", GetLastError()); CloseHandle(handle_); return NULL; } return mem; }
void * Win32SharedMemory::create(size_t key, size_t size) { handle_ = CreateFileMapping(INVALID_HANDLE_VALUE, // use paging file NULL, // default security PAGE_READWRITE, // read/write access 0, // maximum object size (high-order DWORD) size, // maximum object size (low-order DWORD) makeKey(key).c_str()); // name of mapping object if(handle_ == NULL) { fprintf(stderr, TEXT("Could not create file mapping object (%d).\n"), GetLastError()); return NULL; } void * mem = MapViewOfFile(handle_, // handle to map object FILE_MAP_ALL_ACCESS, // read/write permission 0, 0, size); if(mem == NULL) { fprintf(stderr, TEXT("Could not map view of file (%d).\n"), GetLastError()); CloseHandle(handle_); return NULL; } return mem; }
CStringArray * EnumRegistryKeys(HKEY root, const CString & group) { CString path; CStringArray * keys; TCHAR itemName[512]; path.LoadString(IDS_PROGRAM_ROOT); path += _T("\\"); path += group; HKEY key; LONG result = makeKey(root, path, &key); if(result != ERROR_SUCCESS) return NULL; keys = new CStringArray; DWORD i = 0; while(TRUE) //lint -e716 { /* loop */ result = ::RegEnumKey(key, i, itemName, sizeof(itemName)/sizeof(TCHAR)); if(result != ERROR_SUCCESS) break; // we have a valid key name keys->SetAtGrow(i, itemName); i++; } /* loop */ ::RegCloseKey(key); return keys; }
void QWSSharedMemory::detach() { #ifndef QT_POSIX_IPC if (shmBase && shmBase != (void*)-1) shmdt(shmBase); #else if (shmBase && shmBase != (void*)-1) munmap(shmBase, shmSize); if (hand > 0) { // get the number of current attachments int shm_nattch = 0; QT_STATBUF st; if (QT_FSTAT(hand, &st) == 0) { // subtract 2 from linkcount: one for our own open and one for the dir entry shm_nattch = st.st_nlink - 2; } qt_safe_close(hand); // if there are no attachments then unlink the shared memory if (shm_nattch == 0) { QByteArray shmName = makeKey(shmId); shm_unlink(shmName.constData()); } } #endif shmBase = 0; shmSize = 0; shmId = -1; }
static void rijndaelVTKAT(FILE *fp, int keyLength) { int i; BYTE block[4*4]; BYTE keyMaterial[320]; keyInstance keyInst; cipherInstance cipherInst; #ifdef TRACE_KAT_MCT printf("Executing Variable-Text KAT (key %d): ", keyLength); fflush(stdout); #endif /* ?TRACE_KAT_MCT */ fprintf(fp, "\n" "==========\n" "\n" "KEYSIZE=%d\n" "\n", keyLength); fflush(fp); memset(keyMaterial, 0, sizeof (keyMaterial)); memset(keyMaterial, '0', keyLength/4); makeKey(&keyInst, DIR_ENCRYPT, keyLength, keyMaterial); fprintf(fp, "KEY=%s\n", keyMaterial); for (i = 0; i < 128; i++) { memset(block, 0, 16); block[i/8] |= 1 << (7 - i%8); /* set only the i-th bit of the i-th test block */ fprintf (fp, "\nI=%d\n", i+1); blockPrint(fp, block, "PT"); cipherInit(&cipherInst, MODE_ECB, NULL); blockEncrypt(&cipherInst, &keyInst, block, 128, block); blockPrint(fp, block, "CT"); } #ifdef TRACE_KAT_MCT printf(" done.\n"); #endif /* ?TRACE_KAT_MCT */ }
FileLineInfo FileLineInfoMap::getInfo(const std::string & key0, const std::string & key1, const std::string & key2) const { return getInfo(makeKey(key0, key1, key2)); }
const Graphics::TFont* TCustomFontsCache::Get(const TCustomFont& font) { const Key key = makeKey(font); if (isLoaded(key) == true) { return loadedFonts.at(key).get(); } else { return load(font); } }
void FileLineInfoMap::addInfo(const std::string & key0, const std::string & key1, const std::string & file, int line) { addInfo(makeKey(key0, key1), file, line); }
int TwoFishCrypt( int direction, /* 1=encrypt or 0=decrypt */ int keySize, const char *passwd, const struct CryptData *data_in, struct CryptData *data_out ) { keyInstance ki; /* key information, including tables */ cipherInstance ci; /* keeps mode (ECB, CBC) and IV */ int i; int pwLen, result; int blkCount = (data_in->len+1)/(BLOCK_SIZE/8) + 1; int byteCnt = (BLOCK_SIZE/8) * blkCount; BYTE * input = (BYTE *) calloc(byteCnt,1); BYTE * output = (BYTE *) calloc(byteCnt,1); memcpy(input, data_in->data, byteCnt); if ( !makeKey(&ki,DIR_ENCRYPT,keySize,NULL) ) { free(input); free(output); return 0; } if ( !cipherInit(&ci,MODE_ECB,NULL) ) { free(input); free(output); return 0; } /* Set key bits from password. */ pwLen = strlen(passwd); for (i=0;i<keySize/32;i++) /* select key bits */ { ki.key32[i] = (i < pwLen) ? passwd[i] : 0; ki.key32[i] ^= passwd[0]; } reKey(&ki); /* encrypt the bytes */ result = direction ? blockEncrypt(&ci, &ki, input, byteCnt*8, output) : blockDecrypt(&ci, &ki, input, byteCnt*8, output); if(result == byteCnt*8) { data_out->data = (BYTE *) malloc(byteCnt); memcpy(data_out->data, output, byteCnt); data_out->len = byteCnt; free(input); free(output); return 1; } free(input); free(output); return 0; }
bool QWSSharedMemory::create(int size) { if (shmId != -1) detach(); #ifndef QT_POSIX_IPC shmId = shmget(IPC_PRIVATE, size, IPC_CREAT | 0600); #else // ### generate really unique IDs shmId = (getpid() << 16) + (localUniqueId.fetchAndAddRelaxed(1) % ushort(-1)); QByteArray shmName = makeKey(shmId); EINTR_LOOP(hand, shm_open(shmName.constData(), O_RDWR | O_CREAT, 0660)); if (hand != -1) { // the size may only be set once; ignore errors int ret; EINTR_LOOP(ret, ftruncate(hand, size)); if (ret == -1) shmId = -1; } else { shmId = -1; } #endif if (shmId == -1) { #ifdef QT_SHM_DEBUG perror("QWSSharedMemory::create():"); qWarning("Error allocating shared memory of size %d", size); #endif detach(); return false; } #ifndef QT_POSIX_IPC shmBase = shmat(shmId, 0, 0); // On Linux, it is possible to attach a shared memory segment even if it // is already marked to be deleted. However, POSIX.1-2001 does not specify // this behaviour and many other implementations do not support it. shmctl(shmId, IPC_RMID, 0); #else // grab the size QT_STATBUF st; if (QT_FSTAT(hand, &st) != -1) { shmSize = st.st_size; // grab the memory shmBase = mmap(0, shmSize, PROT_READ | PROT_WRITE, MAP_SHARED, hand, 0); } #endif if (shmBase == (void*)-1 || !shmBase) { #ifdef QT_SHM_DEBUG perror("QWSSharedMemory::create():"); qWarning("Error attaching to shared memory id %d", shmId); #endif detach(); return false; } return true; }
////////////////////////////////////////////////////////////////////// // Adds a given set of goals as not satisfiable in the memoization //level ////////////////////////////////////////////////////////////////////// void MemoizationLevel::addNoGood(IntVector &ivGoals) { string sKey=makeKey(ivGoals); if(ivmNoGoods.find(sKey) == ivmNoGoods.end()) { ivmNoGoods[sKey]=true; } }
void TokenDatabase::generateKey(const Context &context, const AccessCredentials *cred, const AclEntryPrototype *owner, CSSM_KEYUSE pubUsage, CSSM_KEYATTR_FLAGS pubAttrs, CSSM_KEYUSE privUsage, CSSM_KEYATTR_FLAGS privAttrs, RefPointer<Key> &publicKey, RefPointer<Key> &privateKey) { Access access(token()); TRY GUARD KeyHandle hPrivate, hPublic; CssmKey *privKey, *pubKey; access().generateKey(context, cred, owner, pubUsage, modattrs(pubAttrs), privUsage, modattrs(privAttrs), hPublic, pubKey, hPrivate, privKey); publicKey = makeKey(hPublic, pubKey, 0, owner); privateKey = makeKey(hPrivate, privKey, 0, owner); DONE }