Result_t AS_02::MXF::AS02IndexWriterVBR::WriteToFile(Kumu::FileWriter& Writer) { assert(m_Dict); ASDCP::FrameBuffer index_body_buffer; ui32_t index_body_size = m_PacketList->m_List.size() * MaxIndexSegmentSize; // segment-count * max-segment-size Result_t result = index_body_buffer.Capacity(index_body_size); ui64_t start_position = 0; if ( m_CurrentSegment != 0 ) { m_CurrentSegment->IndexDuration = m_CurrentSegment->IndexEntryArray.size(); start_position = m_CurrentSegment->IndexStartPosition + m_CurrentSegment->IndexDuration; m_CurrentSegment = 0; } std::list<InterchangeObject*>::iterator pl_i = m_PacketList->m_List.begin(); for ( ; pl_i != m_PacketList->m_List.end() && KM_SUCCESS(result); pl_i++ ) { InterchangeObject* object = *pl_i; object->m_Lookup = m_Lookup; ASDCP::FrameBuffer WriteWrapper; WriteWrapper.SetData(index_body_buffer.Data() + index_body_buffer.Size(), index_body_buffer.Capacity() - index_body_buffer.Size()); result = object->WriteToBuffer(WriteWrapper); index_body_buffer.Size(index_body_buffer.Size() + WriteWrapper.Size()); delete *pl_i; *pl_i = 0; } m_PacketList->m_List.clear(); if ( KM_SUCCESS(result) ) { IndexByteCount = index_body_buffer.Size(); UL body_ul(m_Dict->ul(MDD_ClosedCompleteBodyPartition)); result = Partition::WriteToFile(Writer, body_ul); } if ( KM_SUCCESS(result) ) { ui32_t write_count = 0; result = Writer.Write(index_body_buffer.RoData(), index_body_buffer.Size(), &write_count); assert(write_count == index_body_buffer.Size()); } if ( KM_SUCCESS(result) ) { m_CurrentSegment = new IndexTableSegment(m_Dict); assert(m_CurrentSegment); AddChildObject(m_CurrentSegment); m_CurrentSegment->DeltaEntryArray.push_back(IndexTableSegment::DeltaEntry()); m_CurrentSegment->IndexEditRate = m_EditRate; m_CurrentSegment->IndexStartPosition = start_position; } return result; }
static bool string_is_xml(const ASDCP::FrameBuffer& buffer) { std::string ns_prefix, type_name, namespace_name; Kumu::AttributeList doc_attr_list; return GetXMLDocType(buffer.RoData(), buffer.Size(), ns_prefix, type_name, namespace_name, doc_attr_list); }
Result_t AS_02::h__AS02WriterClip::WriteClipBlock(const ASDCP::FrameBuffer& FrameBuf) { if ( m_ClipStart == 0 ) { DefaultLogSink().Error("Cannot write clip block, no clip open.\n"); return RESULT_STATE; } return m_File.Write(FrameBuf.RoData(), FrameBuf.Size()); }
Result_t ASDCP::IntegrityPack::TestValues(const ASDCP::FrameBuffer& FB, const byte_t* AssetID, ui32_t sequence, HMACContext* HMAC) { ASDCP_TEST_NULL(AssetID); ASDCP_TEST_NULL(HMAC); // find the start of the intpack byte_t* p = (byte_t*)FB.RoData() + ( FB.Size() - klv_intpack_size ); // test the AssetID length if ( ! Kumu::read_test_BER(&p, UUIDlen) ) return RESULT_HMACFAIL; // test the AssetID if ( memcmp(p, AssetID, UUIDlen) != 0 ) { DefaultLogSink().Error("IntegrityPack failure: AssetID mismatch.\n"); return RESULT_HMACFAIL; } p += UUIDlen; // test the sequence length if ( ! Kumu::read_test_BER(&p, sizeof(ui64_t)) ) return RESULT_HMACFAIL; ui32_t test_sequence = (ui32_t)KM_i64_BE(Kumu::cp2i<ui64_t>(p)); // test the sequence value if ( test_sequence != sequence ) { DefaultLogSink().Error("IntegrityPack failure: sequence is %u, expecting %u.\n", test_sequence, sequence); return RESULT_HMACFAIL; } p += sizeof(ui64_t); // test the HMAC length if ( ! Kumu::read_test_BER(&p, HMAC_SIZE) ) return RESULT_HMACFAIL; // test the HMAC HMAC->Reset(); HMAC->Update(FB.RoData(), FB.Size() - HMAC_SIZE); HMAC->Finalize(); return HMAC->TestHMACValue(p); }
Result_t ASDCP::IntegrityPack::CalcValues(const ASDCP::FrameBuffer& FB, const byte_t* AssetID, ui32_t sequence, HMACContext* HMAC) { ASDCP_TEST_NULL(AssetID); ASDCP_TEST_NULL(HMAC); byte_t* p = Data; HMAC->Reset(); static byte_t ber_4[MXF_BER_LENGTH] = {0x83, 0, 0, 0}; // update HMAC with essence data HMAC->Update(FB.RoData(), FB.Size()); // track file ID length memcpy(p, ber_4, MXF_BER_LENGTH); *(p+3) = UUIDlen;; p += MXF_BER_LENGTH; // track file ID memcpy(p, AssetID, UUIDlen); p += UUIDlen; // sequence length memcpy(p, ber_4, MXF_BER_LENGTH); *(p+3) = sizeof(ui64_t); p += MXF_BER_LENGTH; // sequence number Kumu::i2p<ui64_t>(KM_i64_BE(sequence), p); p += sizeof(ui64_t); // HMAC length memcpy(p, ber_4, MXF_BER_LENGTH); *(p+3) = HMAC_SIZE; p += MXF_BER_LENGTH; // update HMAC with intpack values HMAC->Update(Data, klv_intpack_size - HMAC_SIZE); // finish & write HMAC HMAC->Finalize(); HMAC->GetHMACValue(p); assert(p + HMAC_SIZE == Data + klv_intpack_size); return RESULT_OK; }
Result_t AS_02::MXF::AS02IndexWriterCBR::WriteToFile(Kumu::FileWriter& Writer) { assert(m_Dict); ASDCP::FrameBuffer index_body_buffer; ui32_t index_body_size = MaxIndexSegmentSize; // segment-count * max-segment-size Result_t result = index_body_buffer.Capacity(index_body_size); m_CurrentSegment = new IndexTableSegment(m_Dict); assert(m_CurrentSegment); m_CurrentSegment->m_Lookup = m_Lookup; m_CurrentSegment->IndexEditRate = m_EditRate; m_CurrentSegment->IndexStartPosition = 0; m_CurrentSegment->IndexDuration = m_Duration; m_CurrentSegment->EditUnitByteCount = m_SampleSize; AddChildObject(m_CurrentSegment); ASDCP::FrameBuffer WriteWrapper; WriteWrapper.SetData(index_body_buffer.Data() + index_body_buffer.Size(), index_body_buffer.Capacity() - index_body_buffer.Size()); result = m_CurrentSegment->WriteToBuffer(WriteWrapper); index_body_buffer.Size(index_body_buffer.Size() + WriteWrapper.Size()); delete m_CurrentSegment; m_CurrentSegment = 0; m_PacketList->m_List.clear(); if ( KM_SUCCESS(result) ) { IndexByteCount = index_body_buffer.Size(); UL body_ul(m_Dict->ul(MDD_ClosedCompleteBodyPartition)); result = Partition::WriteToFile(Writer, body_ul); } if ( KM_SUCCESS(result) ) { ui32_t write_count = 0; result = Writer.Write(index_body_buffer.RoData(), index_body_buffer.Size(), &write_count); assert(write_count == index_body_buffer.Size()); } return result; }
ASDCP::Result_t ASDCP::KLVPacket::WriteKLToBuffer(ASDCP::FrameBuffer& Buffer, const UL& label, ui32_t length) { assert(label.HasValue()); if ( Buffer.Size() + kl_length > Buffer.Capacity() ) { DefaultLogSink().Error("Small write buffer\n"); return RESULT_FAIL; } memcpy(Buffer.Data() + Buffer.Size(), label.Value(), label.Size()); if ( ! Kumu::write_BER(Buffer.Data() + Buffer.Size() + SMPTE_UL_LENGTH, length, MXF_BER_LENGTH) ) return RESULT_FAIL; Buffer.Size(Buffer.Size() + kl_length); return RESULT_OK; }
// base subroutine for reading a KLV packet, assumes file position is at the first byte of the packet Result_t ASDCP::Read_EKLV_Packet(Kumu::FileReader& File, const ASDCP::Dictionary& Dict, const ASDCP::WriterInfo& Info, Kumu::fpos_t& LastPosition, ASDCP::FrameBuffer& CtFrameBuf, ui32_t FrameNum, ui32_t SequenceNum, ASDCP::FrameBuffer& FrameBuf, const byte_t* EssenceUL, AESDecContext* Ctx, HMACContext* HMAC) { KLReader Reader; Result_t result = Reader.ReadKLFromFile(File); if ( KM_FAILURE(result) ) return result; UL Key(Reader.Key()); ui64_t PacketLength = Reader.Length(); LastPosition = LastPosition + Reader.KLLength() + PacketLength; if ( Key.MatchIgnoreStream(Dict.ul(MDD_CryptEssence)) ) // ignore the stream numbers { if ( ! Info.EncryptedEssence ) { DefaultLogSink().Error("EKLV packet found, no Cryptographic Context in header.\n"); return RESULT_FORMAT; } // read encrypted triplet value into internal buffer assert(PacketLength <= 0xFFFFFFFFL); CtFrameBuf.Capacity((ui32_t) PacketLength); ui32_t read_count; result = File.Read(CtFrameBuf.Data(), (ui32_t) PacketLength, &read_count); if ( ASDCP_FAILURE(result) ) return result; if ( read_count != PacketLength ) { DefaultLogSink().Error("read length is smaller than EKLV packet length.\n"); return RESULT_FORMAT; } CtFrameBuf.Size((ui32_t) PacketLength); // should be const but mxflib::ReadBER is not byte_t* ess_p = CtFrameBuf.Data(); // read context ID length if ( ! Kumu::read_test_BER(&ess_p, UUIDlen) ) return RESULT_FORMAT; // test the context ID if ( memcmp(ess_p, Info.ContextID, UUIDlen) != 0 ) { DefaultLogSink().Error("Packet's Cryptographic Context ID does not match the header.\n"); return RESULT_FORMAT; } ess_p += UUIDlen; // read PlaintextOffset length if ( ! Kumu::read_test_BER(&ess_p, sizeof(ui64_t)) ) return RESULT_FORMAT; ui32_t PlaintextOffset = (ui32_t)KM_i64_BE(Kumu::cp2i<ui64_t>(ess_p)); ess_p += sizeof(ui64_t); // read essence UL length if ( ! Kumu::read_test_BER(&ess_p, SMPTE_UL_LENGTH) ) return RESULT_FORMAT; // test essence UL if ( ! UL(ess_p).MatchIgnoreStream(EssenceUL) ) // ignore the stream number { char strbuf[IntBufferLen]; const MDDEntry* Entry = Dict.FindUL(Key.Value()); if ( Entry == 0 ) { DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Key.EncodeString(strbuf, IntBufferLen)); } else { DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Entry->name); } return RESULT_FORMAT; } ess_p += SMPTE_UL_LENGTH; // read SourceLength length if ( ! Kumu::read_test_BER(&ess_p, sizeof(ui64_t)) ) return RESULT_FORMAT; ui32_t SourceLength = (ui32_t)KM_i64_BE(Kumu::cp2i<ui64_t>(ess_p)); ess_p += sizeof(ui64_t); assert(SourceLength); if ( FrameBuf.Capacity() < SourceLength ) { DefaultLogSink().Error("FrameBuf.Capacity: %u SourceLength: %u\n", FrameBuf.Capacity(), SourceLength); return RESULT_SMALLBUF; } ui32_t esv_length = calc_esv_length(SourceLength, PlaintextOffset); // read ESV length if ( ! Kumu::read_test_BER(&ess_p, esv_length) ) { DefaultLogSink().Error("read_test_BER did not return %u\n", esv_length); return RESULT_FORMAT; } ui32_t tmp_len = esv_length + (Info.UsesHMAC ? klv_intpack_size : 0); if ( PacketLength < tmp_len ) { DefaultLogSink().Error("Frame length is larger than EKLV packet length.\n"); return RESULT_FORMAT; } if ( Ctx ) { // wrap the pointer and length as a FrameBuffer for use by // DecryptFrameBuffer() and TestValues() FrameBuffer TmpWrapper; TmpWrapper.SetData(ess_p, tmp_len); TmpWrapper.Size(tmp_len); TmpWrapper.SourceLength(SourceLength); TmpWrapper.PlaintextOffset(PlaintextOffset); result = DecryptFrameBuffer(TmpWrapper, FrameBuf, Ctx); FrameBuf.FrameNumber(FrameNum); // detect and test integrity pack if ( ASDCP_SUCCESS(result) && Info.UsesHMAC && HMAC ) { IntegrityPack IntPack; result = IntPack.TestValues(TmpWrapper, Info.AssetUUID, SequenceNum, HMAC); } } else // return ciphertext to caller { if ( FrameBuf.Capacity() < tmp_len ) { char intbuf[IntBufferLen]; DefaultLogSink().Error("FrameBuf.Capacity: %u FrameLength: %s\n", FrameBuf.Capacity(), ui64sz(PacketLength, intbuf)); return RESULT_SMALLBUF; } memcpy(FrameBuf.Data(), ess_p, tmp_len); FrameBuf.Size(tmp_len); FrameBuf.FrameNumber(FrameNum); FrameBuf.SourceLength(SourceLength); FrameBuf.PlaintextOffset(PlaintextOffset); } } else if ( Key.MatchIgnoreStream(EssenceUL) ) // ignore the stream number { // read plaintext frame if ( FrameBuf.Capacity() < PacketLength ) { char intbuf[IntBufferLen]; DefaultLogSink().Error("FrameBuf.Capacity: %u FrameLength: %s\n", FrameBuf.Capacity(), ui64sz(PacketLength, intbuf)); return RESULT_SMALLBUF; } // read the data into the supplied buffer ui32_t read_count; assert(PacketLength <= 0xFFFFFFFFL); result = File.Read(FrameBuf.Data(), (ui32_t) PacketLength, &read_count); if ( ASDCP_FAILURE(result) ) return result; if ( read_count != PacketLength ) { char intbuf1[IntBufferLen]; char intbuf2[IntBufferLen]; DefaultLogSink().Error("read_count: %s != FrameLength: %s\n", ui64sz(read_count, intbuf1), ui64sz(PacketLength, intbuf2) ); return RESULT_READFAIL; } FrameBuf.FrameNumber(FrameNum); FrameBuf.Size(read_count); } else { char strbuf[IntBufferLen]; const MDDEntry* Entry = Dict.FindUL(Key.Value()); if ( Entry == 0 ) { DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Key.EncodeString(strbuf, IntBufferLen)); } else { DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Entry->name); } return RESULT_FORMAT; } return result; }
Result_t ASDCP::DecryptFrameBuffer(const ASDCP::FrameBuffer& FBin, ASDCP::FrameBuffer& FBout, AESDecContext* Ctx) { ASDCP_TEST_NULL(Ctx); assert(FBout.Capacity() >= FBin.SourceLength()); ui32_t ct_size = FBin.SourceLength() - FBin.PlaintextOffset(); ui32_t diff = ct_size % CBC_BLOCK_SIZE; ui32_t block_size = ct_size - diff; assert(block_size); assert((block_size % CBC_BLOCK_SIZE) == 0); const byte_t* buf = FBin.RoData(); // get ivec Ctx->SetIVec(buf); buf += CBC_BLOCK_SIZE; // decrypt and test check value byte_t CheckValue[CBC_BLOCK_SIZE]; Result_t result = Ctx->DecryptBlock(buf, CheckValue, CBC_BLOCK_SIZE); buf += CBC_BLOCK_SIZE; if ( memcmp(CheckValue, ESV_CheckValue, CBC_BLOCK_SIZE) != 0 ) return RESULT_CHECKFAIL; // copy plaintext region if ( FBin.PlaintextOffset() > 0 ) { memcpy(FBout.Data(), buf, FBin.PlaintextOffset()); buf += FBin.PlaintextOffset(); } // decrypt all but last block if ( ASDCP_SUCCESS(result) ) { result = Ctx->DecryptBlock(buf, FBout.Data() + FBin.PlaintextOffset(), block_size); buf += block_size; } // decrypt last block if ( ASDCP_SUCCESS(result) ) { byte_t the_last_block[CBC_BLOCK_SIZE]; result = Ctx->DecryptBlock(buf, the_last_block, CBC_BLOCK_SIZE); if ( the_last_block[diff] != 0 ) { DefaultLogSink().Error("Unexpected non-zero padding value.\n"); return RESULT_FORMAT; } if ( diff > 0 ) memcpy(FBout.Data() + FBin.PlaintextOffset() + block_size, the_last_block, diff); } if ( ASDCP_SUCCESS(result) ) FBout.Size(FBin.SourceLength()); return result; }
Result_t ASDCP::EncryptFrameBuffer(const ASDCP::FrameBuffer& FBin, ASDCP::FrameBuffer& FBout, AESEncContext* Ctx) { ASDCP_TEST_NULL(Ctx); FBout.Size(0); // size the buffer Result_t result = FBout.Capacity(calc_esv_length(FBin.Size(), FBin.PlaintextOffset())); // write the IV byte_t* p = FBout.Data(); // write the IV to the frame buffer Ctx->GetIVec(p); p += CBC_BLOCK_SIZE; // encrypt the check value to the frame buffer if ( ASDCP_SUCCESS(result) ) { result = Ctx->EncryptBlock(ESV_CheckValue, p, CBC_BLOCK_SIZE); p += CBC_BLOCK_SIZE; } // write optional plaintext region if ( FBin.PlaintextOffset() > 0 ) { assert(FBin.PlaintextOffset() <= FBin.Size()); memcpy(p, FBin.RoData(), FBin.PlaintextOffset()); p += FBin.PlaintextOffset(); } ui32_t ct_size = FBin.Size() - FBin.PlaintextOffset(); ui32_t diff = ct_size % CBC_BLOCK_SIZE; ui32_t block_size = ct_size - diff; assert((block_size % CBC_BLOCK_SIZE) == 0); // encrypt the ciphertext region essence data if ( ASDCP_SUCCESS(result) ) { result = Ctx->EncryptBlock(FBin.RoData() + FBin.PlaintextOffset(), p, block_size); p += block_size; } // construct and encrypt the padding if ( ASDCP_SUCCESS(result) ) { byte_t the_last_block[CBC_BLOCK_SIZE]; if ( diff > 0 ) memcpy(the_last_block, FBin.RoData() + FBin.PlaintextOffset() + block_size, diff); for (ui32_t i = 0; diff < CBC_BLOCK_SIZE; diff++, i++ ) the_last_block[diff] = i; result = Ctx->EncryptBlock(the_last_block, p, CBC_BLOCK_SIZE); } if ( ASDCP_SUCCESS(result) ) FBout.Size(calc_esv_length(FBin.Size(), FBin.PlaintextOffset())); return result; }
ASDCP::Result_t ASDCP::RawEssenceType(const std::string& filename, EssenceType_t& type) { type = ESS_UNKNOWN; ASDCP::FrameBuffer FB; Kumu::FileReader Reader; ASDCP::Wav::SimpleWaveHeader WavHeader; ASDCP::RF64::SimpleRF64Header RF64Header; ASDCP::AIFF::SimpleAIFFHeader AIFFHeader; Kumu::XMLElement TmpElement("Tmp"); ui32_t data_offset; ui32_t read_count; Result_t result = FB.Capacity(Wav::MaxWavHeader); // using Wav max because everything else is much smaller if ( Kumu::PathIsFile(filename) ) { result = Reader.OpenRead(filename); if ( ASDCP_SUCCESS(result) ) { result = Reader.Read(FB.Data(), FB.Capacity(), &read_count); Reader.Close(); } if ( ASDCP_SUCCESS(result) ) { const byte_t* p = FB.RoData(); FB.Size(read_count); ui32_t i = 0; while ( p[i] == 0 ) i++; if ( i > 1 && p[i] == 1 && (p[i+1] == ASDCP::MPEG2::SEQ_START || p[i+1] == ASDCP::MPEG2::PIC_START) ) { type = ESS_MPEG2_VES; } else if ( memcmp(FB.RoData(), ASDCP::JP2K::Magic, sizeof(ASDCP::JP2K::Magic)) == 0 ) { type = ESS_JPEG_2000; } else if ( ASDCP_SUCCESS(WavHeader.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) ) { switch ( WavHeader.samplespersec ) { case 48000: type = ESS_PCM_24b_48k; break; case 96000: type = ESS_PCM_24b_96k; break; default: return RESULT_FORMAT; } } else if ( ASDCP_SUCCESS(RF64Header.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) ) { switch ( RF64Header.samplespersec ) { case 48000: type = ESS_PCM_24b_48k; break; case 96000: type = ESS_PCM_24b_96k; break; default: return RESULT_FORMAT; } } else if ( ASDCP_SUCCESS(AIFFHeader.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) ) { type = ESS_PCM_24b_48k; } else if ( string_is_xml(FB) ) { type = ESS_TIMED_TEXT; } else if ( ASDCP::ATMOS::IsDolbyAtmos(filename) ) { type = ESS_DCDATA_DOLBY_ATMOS; } } } else if ( Kumu::PathIsDirectory(filename) ) { char next_file[Kumu::MaxFilePath]; Kumu::DirScanner Scanner; Result_t result = Scanner.Open(filename); if ( ASDCP_SUCCESS(result) ) { while ( ASDCP_SUCCESS(Scanner.GetNext(next_file)) ) { if ( next_file[0] == '.' ) // no hidden files or internal links continue; result = Reader.OpenRead(Kumu::PathJoin(filename, next_file)); if ( ASDCP_SUCCESS(result) ) { result = Reader.Read(FB.Data(), FB.Capacity(), &read_count); Reader.Close(); } if ( ASDCP_SUCCESS(result) ) { if ( memcmp(FB.RoData(), ASDCP::JP2K::Magic, sizeof(ASDCP::JP2K::Magic)) == 0 ) { type = ESS_JPEG_2000; } else if ( ASDCP_SUCCESS(WavHeader.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) ) { switch ( WavHeader.samplespersec ) { case 48000: type = ESS_PCM_24b_48k; break; case 96000: type = ESS_PCM_24b_96k; break; default: return RESULT_FORMAT; } } else if ( ASDCP_SUCCESS(RF64Header.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) ) { switch ( RF64Header.samplespersec ) { case 48000: type = ESS_PCM_24b_48k; break; case 96000: type = ESS_PCM_24b_96k; break; default: return RESULT_FORMAT; } } else if ( ASDCP::ATMOS::IsDolbyAtmos(Kumu::PathJoin(filename, next_file)) ) { type = ESS_DCDATA_DOLBY_ATMOS; } else { type = ESS_DCDATA_UNKNOWN; } } break; } } } return result; }