FileBase::FileBase(int data_fd, int meta_fd, const key_type& key_, const id_type& id_, bool check) : m_lock() , m_refcount(1) , m_header() , m_id(id_) , m_data_fd(data_fd) , m_meta_fd(meta_fd) , m_dirty(false) , m_check(check) , m_stream() , m_removed(false) { auto data_stream = std::make_shared<POSIXFileStream>(data_fd); auto meta_stream = std::make_shared<POSIXFileStream>(meta_fd); key_type data_key, meta_key; byte generated_keys[KEY_LENGTH * 3]; hkdf(key_.data(), key_.size(), nullptr, 0, id_.data(), id_.size(), generated_keys, sizeof(generated_keys)); memcpy(data_key.data(), generated_keys, KEY_LENGTH); memcpy(meta_key.data(), generated_keys + KEY_LENGTH, KEY_LENGTH); memcpy(m_key.data(), generated_keys + 2 * KEY_LENGTH, KEY_LENGTH); auto crypt = make_cryptstream_aes_gcm( std::move(data_stream), std::move(meta_stream), data_key, meta_key, id_, check); m_stream = crypt.first; m_header = crypt.second; read_header(); }
iterator insert( const key_type& key) { if( empty()) { keys().push_back( key); return begin(); } if( key.time() < front().time()) { keys().insert( begin(), key); return begin(); } if( key.time() > back().time()) { keys().push_back( key); return end() - 1; } iterator it( lower_bound( key.time())); if( abs( it->time() - key.time()) <= keyframe_t::time_tolerance()) { *it = key; return it; } else return keys().insert( it, key); }
const key_type& key() { if(!reversed_key_) { key_.set_bits(0, ary_->lsize(), ary_->inverse_matrix().times(key_)); reversed_key_ = true; } return key_; }
slirc::channeluser_list::size_type slirc::channeluser_list::erase(const key_type &key) { slirc::channeluser_list::size_type ret = baseclass::erase(key); if (ret && detacher) { key->detach(); } return ret; }
void operator()(const key_type &key, std::array<M128I<U>, Rp1> &rk) const { M128I<std::uint64_t> weyl; weyl.set( ARSWeylConstantTrait<1>::value, ARSWeylConstantTrait<0>::value); std::get<0>(rk).load(key.data()); generate<1>(rk, weyl, std::integral_constant<bool, 1 < Rp1>()); }
bool next() { key_status success = array::EMPTY; while(success != array::FILLED && id_ < end_id_) success = ary_->get_key_val_at_id(id_++, key_, val_); if(success == array::FILLED) key_.set_bits(0, ary_->lsize(), ary_->inverse_matrix().times(key_)); return success == array::FILLED; }
FileTable::FileTable(int version, std::shared_ptr<FileSystemService> root, const key_type& master_key, uint32_t flags, unsigned block_size, unsigned iv_size) : m_flags(flags), m_block_size(block_size), m_iv_size(iv_size), m_root(root) { memcpy(m_master_key.data(), master_key.data(), master_key.size()); switch (version) { case 1: m_fio.reset(new FileTableIOVersion1(root, is_readonly())); break; case 2: m_fio.reset(new FileTableIOVersion2(root, is_readonly())); break; default: throw InvalidArgumentException("Unknown version"); } }
bool next() { reversed_key_ = false; bool found_oid = false; while(!found_oid && id_ < mid_) { if(ary_->get_key_at_id((start_id_ + id_++) & mask_, *key_, &w_, &o_) == array::FILLED) { oid_ = key_->get_bits(0, ary_->lsize()); found_oid = start_id_ <= oid_ && oid_ < end_id_; } } return found_oid; }
MappingIterator::MappingIterator(const ObjectHandle& containerHandle, const container_type& container, const key_type& key, const Converters& typeConverters) : containerHandle_(containerHandle), container_(container), keys_(container_.keys(PyScript::ScriptErrorPrint())), index_(0), key_(key), typeConverters_(typeConverters) { if (!key_.exists()) { index_ = container_.size(); } else { bool found = false; // If the key is not found, then index_ == end for (; index_ < keys_.size(); ++index_) { auto scriptKey = keys_.getItem(index_); if (key.compareTo(scriptKey, PyScript::ScriptErrorPrint()) == 0) { found = true; break; } } // HACK NGT-1603 Try to cast key to an index // Work-around for how ReflectedPropertyItem::getChild will try to // access items with the a string "[index]" if (!found) { Variant result; ObjectHandle parentHandle; const char* childPath = ""; const bool success = typeConverters_.toVariant(key_, result, parentHandle, childPath); PyScript::ScriptList::size_type fakeIndex = container_.size(); const bool isIndex = result.tryCast(fakeIndex); if (isIndex && (fakeIndex >= 0) && (fakeIndex < container_.size())) { index_ = fakeIndex; key_ = keys_.getItem(index_); } } } }
typename Matrix::size_type operator() (key_type const& key) const { return key.col(); }
reference operator[](key_type key) const { return (*internal_vector)[key->id()]; }
math::natural traits<phys::constraint::unilateral::key>::dimension(key_type k) { return k->dim(); }
inline friend reference get(const Constrained_edge_map& em, key_type e) { bool b = em.sm_.property(em.constraint,em.sm_.edge_handle(e.idx())); return b; }
/*! * The method finds the attribute value by name. * * \param key Attribute name. * \return Iterator to the found element or \c end() if the attribute with such name is not found. */ const_iterator find(key_type const& key) const { return find_impl(key.data(), key.size()); }
bool operator()(const key_type& x, const key_type& y) const { return x.here() < y.here(); }
int atoi_fast::atoi(const key_type& k, int offset) const { char* string = k.get(); int l = k.size(); return atoi((const char*)string, l, offset, 0); }
value_type operator[] (const key_type& k) const { return k.get_id(); }
void init_decrypt(AES_KEY &ctx, const key_type &key, const iv_type &iv) { AES_set_decrypt_key(&key[0], key.size() * 8, &ctx); }
void init_decrypt(AES_KEY &ctx, const key_type &key, const iv_type &iv) { // 같은 키 초기화함수를 통해 복호화해야 한다. AES_set_encrypt_key(&key[0], key.size() * 8, &ctx); }
bool operator()(ticket_type xk, const key_type& y) const { return xk < y.here(); }
size_t pos() const { return key_.get_bits(0, ary_->lsize()); }
// The put function is required by the property map concept. friend void put(const Extended_face_property_map& map, key_type key, value_type val) { key->set_data(val); }
bool operator()(const key_type& x, ticket_type yk) const { return x.here() < yk; }
result_type operator() (key_type const& left, key_type const& right) const { return left.id() < right.id(); }
#include <string.h> #include <errno.h> #include <vector> #include <algorithm> #include <set> #include <fcntl.h> #include <unistd.h> TEST_CASE("File table") { using namespace securefs; char dir_template[] = "/tmp/securefs_file_table.XXXXXXX"; mkdtemp(dir_template); key_type master_key; id_type null_id, file_id; memset(master_key.data(), 0xFF, master_key.size()); memset(null_id.data(), 0, null_id.size()); memset(file_id.data(), 0xEE, file_id.size()); const char* xattr_name = "com.apple.FinderInfo..."; const securefs::PODArray<char, 32> xattr_value(0x11); { int tmp_fd = ::open(dir_template, O_RDONLY); REQUIRE(tmp_fd >= 0); FileTable table(tmp_fd, master_key, 0); auto dir = dynamic_cast<Directory*>(table.create_as(null_id, FileBase::DIRECTORY)); dir->add_entry(".", null_id, FileBase::DIRECTORY); dir->add_entry("..", null_id, FileBase::DIRECTORY); dir->add_entry("hello", file_id, FileBase::REGULAR_FILE);
// The get function is required by the property map concept. friend reference get(const Extended_face_property_map& /* map */, key_type key) { return key->data(); }
reference operator[](key_type const& e) const { return e->is_border() || is_constrained(e) ; }
// The put function is required by the property map concept. friend void put(Extended_face_property_map /* map */, key_type key, value_type val) { key->set_data(val); }
inline friend void put(const Constrained_edge_map& em, key_type e, value_type b) { em.sm_.property(em.constraint,em.sm_.edge_handle(e.idx())) = b; }
void init_decrypt(SALSA20_ECRYPT_ctx &ctx, const key_type &key, const iv_type &iv) { SALSA20_ECRYPT_keysetup(&ctx, &key[0], key.size() * 8, iv.size() * 8); SALSA20_ECRYPT_ivsetup(&ctx, &iv[0]); }