void LLScriptByteCodeChunk::addFloat(F32 value) { U8 temp[4]; S32 offset = 0; float2bytestream(temp, offset, value); addBytes(temp, 4); }
void LLScriptByteCodeChunk::addU16(U16 data) { U8 temp[2]; S32 offset = 0; u162bytestream(temp, offset, data); addBytes(temp, 2); }
void LLScriptByteCodeChunk::addInteger(S32 value) { U8 temp[4]; S32 offset = 0; integer2bytestream(temp, offset, value); addBytes(temp, 4); }
dBuffer::dBuffer(t_byteCP _buffer, t_int const _bufferSize) : contents(0), current_size(0), read_counter(0), lastInsertedBytes(0), lastRemovedBytes(0) { addBytes(_buffer, _bufferSize); }
R_API bool r_sign_add_anal(RAnal *a, const char *name, ut64 size, const ut8 *bytes, ut64 at) { ut8 *mask = NULL; bool retval = true; mask = r_anal_mask (a, size, bytes, at); retval = addBytes (a, name, size, bytes, mask); free (mask); return retval; }
void QPF::addHeader(QFontEngine *fontEngine) { QFontEngineQPF::Header *header = reinterpret_cast<QFontEngineQPF::Header *>(addBytes(sizeof(QFontEngineQPF::Header))); header->magic[0] = 'Q'; header->magic[1] = 'P'; header->magic[2] = 'F'; header->magic[3] = '2'; if (options & RenderGlyphs) header->lock = 0xffffffff; else header->lock = 0; header->majorVersion = QFontEngineQPF::CurrentMajorVersion; header->minorVersion = QFontEngineQPF::CurrentMinorVersion; header->dataSize = 0; int oldSize = qpf.size(); addTaggedString(QFontEngineQPF::Tag_FontName, fontEngine->fontDef.family.toUtf8()); QFontEngine::FaceId face = fontEngine->faceId(); addTaggedString(QFontEngineQPF::Tag_FileName, face.filename); addTaggedUInt32(QFontEngineQPF::Tag_FileIndex, face.index); { const QByteArray head = fontEngine->getSfntTable(MAKE_TAG('h', 'e', 'a', 'd')); const quint32 revision = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(head.constData()) + 4); addTaggedUInt32(QFontEngineQPF::Tag_FontRevision, revision); } addTaggedQFixed(QFontEngineQPF::Tag_Ascent, fontEngine->ascent()); addTaggedQFixed(QFontEngineQPF::Tag_Descent, fontEngine->descent()); addTaggedQFixed(QFontEngineQPF::Tag_Leading, fontEngine->leading()); addTaggedQFixed(QFontEngineQPF::Tag_XHeight, fontEngine->xHeight()); addTaggedQFixed(QFontEngineQPF::Tag_AverageCharWidth, fontEngine->averageCharWidth()); addTaggedQFixed(QFontEngineQPF::Tag_MaxCharWidth, QFixed::fromReal(fontEngine->maxCharWidth())); addTaggedQFixed(QFontEngineQPF::Tag_LineThickness, fontEngine->lineThickness()); addTaggedQFixed(QFontEngineQPF::Tag_MinLeftBearing, QFixed::fromReal(fontEngine->minLeftBearing())); addTaggedQFixed(QFontEngineQPF::Tag_MinRightBearing, QFixed::fromReal(fontEngine->minRightBearing())); addTaggedQFixed(QFontEngineQPF::Tag_UnderlinePosition, fontEngine->underlinePosition()); addTaggedUInt8(QFontEngineQPF::Tag_PixelSize, fontEngine->fontDef.pixelSize); addTaggedUInt8(QFontEngineQPF::Tag_Weight, fontEngine->fontDef.weight); addTaggedUInt8(QFontEngineQPF::Tag_Style, fontEngine->fontDef.style); QByteArray writingSystemBitField = getWritingSystems(fontEngine); if (!writingSystemBitField.isEmpty()) addTaggedString(QFontEngineQPF::Tag_WritingSystems, writingSystemBitField); addTaggedUInt8(QFontEngineQPF::Tag_GlyphFormat, QFontEngineQPF::AlphamapGlyphs); addTaggedString(QFontEngineQPF::Tag_EndOfHeader, QByteArray()); align4(); header = reinterpret_cast<QFontEngineQPF::Header *>(qpf.data()); header->dataSize = qToBigEndian<quint16>(qpf.size() - oldSize); }
ExceptionOr<void> CryptoAlgorithmSHA1::digest(const CryptoAlgorithmParametersDeprecated&, const CryptoOperationData& data, VectorCallback&& callback, VoidCallback&& failureCallback) { auto digest = CryptoDigest::create(CryptoDigest::Algorithm::SHA_1); if (!digest) { failureCallback(); return { }; } digest->addBytes(data.first, data.second); callback(digest->computeHash()); return { }; }
dBuffer& dBuffer::operator+=(dBuffer const& _dbuf) { dBuffer cdbuf = _dbuf; t_uint src_size = cdbuf.size(); t_byte space[src_size]; cdbuf.getBytes(space, src_size); addBytes(space, src_size); return *this; }
void CryptoAlgorithmSHA1::digest(Vector<uint8_t>&& message, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue) { auto digest = CryptoDigest::create(CryptoDigest::Algorithm::SHA_1); if (!digest) { exceptionCallback(OperationError); return; } context.ref(); workQueue.dispatch([digest = WTFMove(digest), message = WTFMove(message), callback = WTFMove(callback), &context]() mutable { digest->addBytes(message.data(), message.size()); auto result = digest->computeHash(); context.postTask([callback = WTFMove(callback), result = WTFMove(result)](ScriptExecutionContext& context) { callback(result); context.deref(); }); }); }
void Serializer::addBytes(const uint8_t *newbuffer, size_t bytesRead, std::function<void(Serializer&)> onReceive) { bool lengthKnown = false; for (uint8_t b : *buffer) { if ((b & 0x80) == 0) { lengthKnown = true; break; } } if (!lengthKnown) { // Pre-read buffer until we know the desired length while (bytesRead) { buffer->push_back(*newbuffer++); bytesRead--; if ((buffer->back() & 0x80) == 0x00) { lengthKnown = true; break; } } } if (!lengthKnown) { // Buffer used and still no length known return; } offset = 0; size_t length = read<size_t>(*this); buffer->reserve(length+offset); if (buffer->size() + bytesRead >= length + offset) { size_t bytesToGetFromNewbuffer = (length + offset) - (buffer->size()); buffer->insert(buffer->end(), newbuffer, newbuffer + bytesToGetFromNewbuffer); newbuffer += bytesToGetFromNewbuffer; bytesRead -= bytesToGetFromNewbuffer; onReceive(*this); buffer->clear(); addBytes(newbuffer, bytesRead, onReceive); } else { buffer->insert(buffer->end(), newbuffer, newbuffer + bytesRead); } }
R_API bool r_sign_add_bytes(RAnal *a, const char *name, ut64 size, const ut8 *bytes, const ut8 *mask) { return addBytes (a, name, size, bytes, mask); }
static void send_dhcp_message (void) { uint8_t allOnes[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; memset(gPB, 0, UDP_DATA_P + sizeof( DHCPdata )); EtherCard::udpPrepare(DHCP_DEST_PORT, (dhcpState == DHCP_STATE_BOUND ? EtherCard::dhcpip : allOnes), DHCP_SRC_PORT); // SRC<->DST ?? if (dhcpState != DHCP_STATE_BOUND) EtherCard::copyMac(gPB + ETH_DST_MAC, allOnes); //force broadcast mac // Build DHCP Packet from buf[UDP_DATA_P] DHCPdata *dhcpPtr = (DHCPdata*) (gPB + UDP_DATA_P); dhcpPtr->op = DHCP_BOOTREQUEST; dhcpPtr->htype = 1; dhcpPtr->hlen = 6; dhcpPtr->xid = currentXid; if (dhcpState == DHCP_STATE_BOUND) { EtherCard::copyIp(dhcpPtr->ciaddr, EtherCard::myip); } EtherCard::copyMac(dhcpPtr->chaddr, EtherCard::mymac); // options defined as option, length, value bufPtr = gPB + UDP_DATA_P + sizeof( DHCPdata ); // DHCP magic cookie, followed by message type static byte cookie[] = { 99, 130, 83, 99, 53, 1 }; addBytes(sizeof cookie, cookie); // addToBuf(53); // DHCP_STATE_SELECTING, DHCP_STATE_REQUESTING // addToBuf(1); // Length addToBuf(dhcpState == DHCP_STATE_INIT ? DHCP_DISCOVER : DHCP_REQUEST); // Client Identifier Option, this is the client mac address addToBuf(61); // Client identifier addToBuf(7); // Length addToBuf(0x01); // Ethernet addBytes(6, EtherCard::mymac); addToBuf(12); // Host name Option addToBuf(10); addBytes(10, (byte*) hostname); if( dhcpState == DHCP_STATE_SELECTING) { addToBuf(50); // Request IP address addToBuf(4); addBytes(4, EtherCard::myip); // Request using server ip address addToBuf(54); // Server IP address addToBuf(4); addBytes(4, EtherCard::dhcpip); } // Additional info in parameter list - minimal list for what we need static byte tail[] = { 55, 3, 1, 3, 6, 255 }; addBytes(sizeof tail, tail); // addToBuf(55); // Parameter request list // addToBuf(3); // Length // addToBuf(1); // Subnet mask // addToBuf(3); // Route/Gateway // addToBuf(6); // DNS Server // addToBuf(255); // end option // packet size will be under 300 bytes EtherCard::udpTransmit((bufPtr - gPB) - UDP_DATA_P); }
void ab_addBytes_x(autoBlock_t *i, autoBlock_t *block) { addBytes(i, block); releaseAutoBlock(block); }
// Build and transmit a DHCP message. // The argument is either DHCP_MSG_DISCOVER or DHCP_MSG_REQUEST static void dhcp_send (byte request, byte flg) { // How should this error be propagated ??? if (!EtherCard::isLinkUp()) return; // Start with a clean buffer memset(gPB, 0, UDP_DATA_P + sizeof(DHCPdata)); EtherCard::udpPrepare(DHCP_DEST_PORT, EtherCard::myip, DHCP_SRC_PORT); EtherCard::copyMac(gPB + ETH_SRC_MAC, EtherCard::mymac); EtherCard::copyMac(gPB + ETH_DST_MAC, allOnes); gPB[IP_TOTLEN_L_P] = 0x82; gPB[IP_PROTO_P] = IP_PROTO_UDP_V; // If we don't know where we're going, go everywhere if (flg) EtherCard::copyIp(gPB + IP_DST_P, allOnes); else EtherCard::copyIp(gPB + IP_DST_P, EtherCard::dhcpip); // Build a DHCP Packet from buf[UDP_DATA_P] DHCPdata *dhcpPtr = (DHCPdata *) (gPB + UDP_DATA_P); dhcpPtr->op = DHCP_BOOTREQUEST; dhcpPtr->htype = 1; dhcpPtr->hlen = 6; dhcpPtr->hops = 0; dhcpPtr->xid = currentXid; dhcpPtr->secs = 0; dhcpPtr->flags = flg ? 0x80 : 0; // Set broadcast flag //dhcpPtr->ciaddr //dhcpPtr->yiaddr //dhcpPtr->siaddr //dhcpPtr->giaddr EtherCard::copyMac(dhcpPtr->chaddr, EtherCard::mymac); //dhcpPtr->sname //dhcpPtr->file // Write the cookie 0x63,0x82,0x53,0x63 into the end of the header static byte cookie[] = { 99, 130, 83, 99 }; bufPtr = gPB + UDP_DATA_P + sizeof(DHCPdata) - sizeof(cookie); addBytes(sizeof(cookie), cookie); // Options are defined as option, length, value addToBuf(53); // DHCP message type addToBuf(1); // Length addToBuf(request);// DHCP_MSG_DISCOVER, DHCP_MSG_REQUEST // Client Identifier Option, this is the client mac address addToBuf(61); // Client identifier addToBuf(7); // Length addToBuf(0x01); // Ethernet addBytes(6, EtherCard::mymac); addToBuf(12); // Host name Option byte len = (byte) strlen(hostname); addToBuf(len); addBytes(len, (byte *) hostname); if (request == DHCP_MSG_REQUEST) { addToBuf(50); // Request IP address addToBuf(4); addBytes(4, EtherCard::myip); addToBuf(54); // Server IP address addToBuf(4); addBytes(4, EtherCard::dhcpip); } // Additional info in parameter list - minimal list for what we need // addToBuf(55); // Parameter request list // addToBuf(3); // Length // addToBuf(1); // Subnet mask // addToBuf(3); // Route/Gateway // addToBuf(6); // DNS Server // addToBuf(255); // end option static byte tail[] = { 55, 3, 1, 3, 6, 255 }; addBytes(sizeof(tail), tail); // The packet size will be under 300 bytes EtherCard::udpTransmit((bufPtr - gPB) - UDP_DATA_P); return; }
void ab_addLine(autoBlock_t *i, char *line) { autoBlock_t gab; addBytes(i, gndBlockLineVar(line, gab)); }
void ab_addFollowBytes(autoBlock_t *i, autoBlock_t *block, uint start) { autoBlock_t gab; addBytes(i, gndFollowBytesVar(block, start, gab)); }
void ab_addSubBytes(autoBlock_t *i, autoBlock_t *block, uint start, uint size) { autoBlock_t gab; addBytes(i, gndSubBytesVar(block, start, size, gab)); }
void ab_addBlock(autoBlock_t *i, void *block, uint size) { autoBlock_t gab; addBytes(i, gndBlockVar(block, size, gab)); }
SigNat sign(PublicKey group, RogueKey rogue, Secret secret, Cert cert, Message msg) { char bsn[MAX_CHAR_ARRAY_LENGTH], m[MAX_CHAR_ARRAY_LENGTH]; char error[MAX_CHAR_ARRAY_LENGTH],c_h[MAX_CHAR_ARRAY_LENGTH]; char hash[MAX_CHAR_ARRAY_LENGTH], inner[MAX_CHAR_ARRAY_LENGTH]; BigInt n_v, c, sv, sf0, sf1, se, see, sew, sr, ser, sw; Origin b; BigInt n,gPrime,g,h,r0,r1,s; BigInt biga,e, p2; BigInt f0,f1,v; Tuple wr,rf0rf1,rwrr,rewrer; BigInt bigt1, bigt2, temp1, temp2, temp3, temp4, temp5, temp6, temp7, w, r; BigInt zeta,bign_V,rf0,rf1, rv, bigt2inv, tilde_TPrime2,n_t; BigInt tilde_T1t, tilde_rf, tilde_N_V,rw,rr,re,ree,rew, rer,hinv, tilde_T1, tilde_T2; Hash hashPub, hashHost ,hashTpm1, hashTpm2; Responses ss; SigNat signat; strcpy(bsn,msg.bsn); strcpy(m,msg.m); b = msg.b; n_v = msg.n_v; if(noOfBits(n_v) > hash_bits){ strcpy(error,"n_v out of bounds"); Abort(error); } n=group.n; gPrime=group.gPrime; g=group.g; h=group.h; r0=group.r0; r1=group.r1; s=group.s; biga = cert.biga; e = cert.e; f0 = secret.f; f1=secret.s; v=secret.t; wr = pick2(rsa_modulus_bits+distribution_bits); w = wr.r; r = wr.m; bigt1 = BImodMult(biga,BImodPower(h,wr.r,n),n); temp1 = BIpower(g,w); temp2 = BIpower(h,e); temp3 = BIpower(gPrime,r); temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3); bigt2 = BImod(temp5,n); zeta = base(bsn,rogue); bign_V = tag(rogue,zeta,f0,f1); rv = pick(random_bits+distribution_bits+hash_bits); rf0rf1 = pick2(halfkeyBits+distribution_bits+hash_bits); rf0 = rf0rf1.r; rf1 = rf0rf1.m; temp1 = BIpower(r0,rf0); temp2 = BIpower(r1,rf1); temp3 = BIpower(s,rv); temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3); tilde_T1t = BImod(temp5,n); temp1 = BIshiftLeft(rf1,halfkeyBits); temp2 = BIadd(rf0, temp1); tilde_rf = BImod(temp2,rogue.rho); tilde_N_V = BImodPower(zeta,tilde_rf,rogue.bigGamma); re = pick(prime_random_bits+distribution_bits+hash_bits); ree = pick(2*prime_total_bits+distribution_bits+hash_bits+1); rwrr = pick2(rsa_modulus_bits+2*distribution_bits+hash_bits); rw = rwrr.r; rr = rwrr.m; rewrer = pick2(prime_total_bits+rsa_modulus_bits+2*distribution_bits+hash_bits+1); rew = rewrer.r; rer = rewrer.m; hinv = BImodInv(h,n); temp1 = tilde_T1t; temp2 = BIpower(bigt1,re); temp3 = BIpower(hinv,rew); temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3); tilde_T1 = BImod(temp5,n); temp1 = BIpower(g,rw); temp2 = BIpower(h,re); temp3 = BIpower(gPrime,rr); temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3); tilde_T2 = BImod(temp5,n); bigt2inv = BImodInv(bigt2,n); temp1 = BIpower(bigt2inv,re); temp2 = BIpower(g,rew); temp3 = BIpower(h,ree); temp4 = BIpower(gPrime,rer); temp5 = BImul(temp1, temp2); temp6 = BImul(temp5, temp3); temp7 = BImul(temp6, temp4); tilde_TPrime2 = BImod(temp7,n); //hash public inputs hashPub = getSha1Hash(); addBI(&hashPub,group.n); addBI(&hashPub,group.g); addBI(&hashPub,group.gPrime); addBI(&hashPub,group.h); addBI(&hashPub,group.r0); addBI(&hashPub,group.r1); addBI(&hashPub,group.s); addBI(&hashPub,group.z); addBI(&hashPub,rogue.gamma); addBI(&hashPub,rogue.bigGamma); addBI(&hashPub,rogue.rho); addBI(&hashPub,zeta); addBI(&hashPub,bigt1); addBI(&hashPub,bigt2); addBI(&hashPub,bign_V); strcpy(hash,hashResult(hashPub)); //hash host inputs hashHost = getSha1Hash(); addBI(&hashHost,tilde_T1); addBI(&hashHost,tilde_T2); addBI(&hashHost,tilde_TPrime2); addBI(&hashHost,tilde_N_V); addBI(&hashHost,n_v); strcpy(c_h,hashResult(hashHost)); n_t = pick(distribution_bits); hashTpm1 = getSha1Hash(); addBytes(&hashTpm1,c_h); addBI(&hashTpm1,n_t); strcpy(inner,hashResult(hashTpm1)); hashTpm2 = getSha1Hash(); addBytes(&hashTpm2,inner); if(b == Card) addByte(&hashTpm2,0); else if (b == Verifier) addByte(&hashTpm2,1); else ; addBytes(&hashTpm2, m); c = BItoNumber(hashResult(hashTpm2)); sv = rval(rv,v,c); sf0 = rval(rf0,f0,c); sf1 = rval(rf1,f1,c); p2 = BIshiftLeft(BItoNumber("1"),prime_total_bits-1); se = rval(re,BIsub(e, p2),c); see = rval(ree,BImul(e,e),c); sw = rval(rw,w,c); sew = rval(rew,BImul(e,w),c); sr = rval(rr,r,c); ser = rval(rer,BImul(e,r),c); ss.sv = sv; ss.sf0 = sf0; ss.sf1 = sf1; ss.se = se; ss.see = see; ss.sw = sw; ss.sew = sew; ss.sr = sr; ss.ser = ser; signat.zeta = zeta; signat.bigt1 = bigt1; signat.bigt2 = bigt2; signat.bign_V = bign_V; signat.c = c; signat.n_t = n_t; signat.ss = ss; return signat; }
void ProtocolStatus::sendStatusString() { auto output = OutputMessagePool::getOutputMessage(); setRawMessages(true); pugi::xml_document doc; pugi::xml_node decl = doc.prepend_child(pugi::node_declaration); decl.append_attribute("version") = "1.0"; pugi::xml_node tsqp = doc.append_child("tsqp"); tsqp.append_attribute("version") = "1.0"; pugi::xml_node serverinfo = tsqp.append_child("serverinfo"); uint64_t uptime = (OTSYS_TIME() - ProtocolStatus::start) / 1000; serverinfo.append_attribute("uptime") = std::to_string(uptime).c_str(); serverinfo.append_attribute("ip") = g_config.getString(ConfigManager::IP).c_str(); serverinfo.append_attribute("servername") = g_config.getString(ConfigManager::SERVER_NAME).c_str(); serverinfo.append_attribute("port") = std::to_string(g_config.getNumber(ConfigManager::LOGIN_PORT)).c_str(); serverinfo.append_attribute("location") = g_config.getString(ConfigManager::LOCATION).c_str(); serverinfo.append_attribute("url") = g_config.getString(ConfigManager::URL).c_str(); serverinfo.append_attribute("server") = STATUS_SERVER_NAME; serverinfo.append_attribute("version") = STATUS_SERVER_VERSION; serverinfo.append_attribute("client") = CLIENT_VERSION_STR; pugi::xml_node owner = tsqp.append_child("owner"); owner.append_attribute("name") = g_config.getString(ConfigManager::OWNER_NAME).c_str(); owner.append_attribute("email") = g_config.getString(ConfigManager::OWNER_EMAIL).c_str(); pugi::xml_node players = tsqp.append_child("players"); players.append_attribute("online") = std::to_string(g_game.getPlayersOnline()).c_str(); players.append_attribute("max") = std::to_string(g_config.getNumber(ConfigManager::MAX_PLAYERS)).c_str(); players.append_attribute("peak") = std::to_string(g_game.getPlayersRecord()).c_str(); pugi::xml_node monsters = tsqp.append_child("monsters"); monsters.append_attribute("total") = std::to_string(g_game.getMonstersOnline()).c_str(); pugi::xml_node npcs = tsqp.append_child("npcs"); npcs.append_attribute("total") = std::to_string(g_game.getNpcsOnline()).c_str(); pugi::xml_node rates = tsqp.append_child("rates"); rates.append_attribute("experience") = std::to_string(g_config.getNumber(ConfigManager::RATE_EXPERIENCE)).c_str(); rates.append_attribute("skill") = std::to_string(g_config.getNumber(ConfigManager::RATE_SKILL)).c_str(); rates.append_attribute("loot") = std::to_string(g_config.getNumber(ConfigManager::RATE_LOOT)).c_str(); rates.append_attribute("magic") = std::to_string(g_config.getNumber(ConfigManager::RATE_MAGIC)).c_str(); rates.append_attribute("spawn") = std::to_string(g_config.getNumber(ConfigManager::RATE_SPAWN)).c_str(); pugi::xml_node map = tsqp.append_child("map"); map.append_attribute("name") = g_config.getString(ConfigManager::MAP_NAME).c_str(); map.append_attribute("author") = g_config.getString(ConfigManager::MAP_AUTHOR).c_str(); uint32_t mapWidth, mapHeight; g_game.getMapDimensions(mapWidth, mapHeight); map.append_attribute("width") = std::to_string(mapWidth).c_str(); map.append_attribute("height") = std::to_string(mapHeight).c_str(); pugi::xml_node motd = tsqp.append_child("motd"); motd.text() = g_config.getString(ConfigManager::MOTD).c_str(); std::ostringstream ss; doc.save(ss, "", pugi::format_raw); std::string data = ss.str(); output->addBytes(data.c_str(), data.size()); send(output); disconnect(); }
void ab_addBytes(autoBlock_t *i, autoBlock_t *block) { addBytes(i, block); }