Search

The development of low-energy, high-performance hardware for cryptocurrency mining is gaining widespread attention. The mining process for proof-of-work (PoW) in conventional cryptocurrencies’ blockchains is increasingly being replaced by application-specific integrated circuits (ASICs). This leads to many security threats for the blockchain network because it decreases security and increases power consumption for mining. Therefore, Scrypt, the most representative ASIC-resistant algorithm, was developed to solve this problem. However, there are still some problems and challenges with the current Scrypt hardware. This article presents a new hardware architecture for the Scrypt algorithm intended for a PoW-based cryptocurrency mining system. The proposed Multi ROMix Scrypt Accelerator (MRSA) hardware architecture applies several optimization techniques: configuration, local-memory computing with high-performance pipelined Multi ROMix and rescheduling resources to significantly increase processing speed, flexibility, and energy efficiency. For evaluation, the MRSA is implemented on field-programmable gate arrays (FPGAs) to examine its actual performance, consumption, and correctness. Evaluation results on a Xilinx system-on-chip (SoC) with the ALVEO U280 Data Center Accelerator Card FPGA show that the MRSA is much more power-efficient than some of the most powerful commercial CPUs, GPUs, and other FPGA implementations. On the ALVEO U280, the MRSA achieves a maximum hash rate of 296.76 kHash/s, a throughput of 304.9 Mbps when reaching a maximum frequency of 259.94 MHz, and a power consumption of 18.12W. The energy efficiency of the MRSA on the ALVEO U280 SoC is 52.83 and 867.88 times higher than those on an RTX 3090 GPU and an i9-10940X CPU, respectively.

A password is a string of characters used to protect access to specified resources from unauthorised users. Anyone with access to the resources should be able to keep the password secret in order to prevent resources from being stolen or misused by those who do not have permission. The system that serves as a resource storage and is also in charge of granting access to those resources should be secure enough to handle access verification. The computer should have a means to validate the password in order to authenticate a person using a password. A security issue arises when a plain password is saved somewhere to be used for verification. Anyone who can identify the location where the password is kept and read it can have access to all of the system's resources. The authentication system should be able to store and validate passwords in a secure manner. With the advancement of computer hardware, the chances of cracking the security of hashing algorithms, such as Bcrypt, are increasing. Certain gear has been developed particularly to execute certain cracking algorithms at their best. To avoid the chance of cracking utilising high-end computer hardware, a more secure hashing technique is required. Argon2 is yet another hashing function that can outperform current hardware in terms of compute power. Argon2 addresses several important flaws in existing algorithms by being designed for the fastest memory filling rate and the most efficient usage of numerous processing units while still offering protection against tradeoff attacks.

U ovom radu prikazani su razni načini pohrane zaporki i problemi koji proizlaze iz načina različitih pohrane. Predstavljene su i različite vrste napada na zaporke. S obzirom na učinkovitost napada grafičkim procesorom, predstavljen je i algoritam scrypt koji je otporan na napade grafičkim procesorom. Izmjerena su vremena potrebna za provedbu napada pomoću običnog i grafičkog procesora za različite duljine zaporki i različite kriptografske algoritme koji se koriste za zaštitu zaporke. This paper presents various ways of storing passwords and problems arising from different storage methods. Different types of password attacks are also presented. Considering the efficiency of GPU attacks, the scrypt algorithm, which is resistant to GPU attacks, was also presented. The time required to perform an attack using a regular processor and GPU for different password lengths and different cryptographic algorithms used to protect the password was measured.

The development of blockchain-based cryptocurren-cies has attracted a lot of interest in many fields, especially in academic research. Besides Bitcoin, Litecoin is one of the most popular cryptocurrency based on blockchain currently. The Litecoin mining process uses the Scrypt algorithm as a hash function in Proof-of-Work (PoW) consensus mechanism. The yield of cryptocurrency mining depends a lot on the processing performance of the hardware. Therefore, this paper proposes a hardware design of the Scrypt algorithm in the Litecoin mining system using the Verilog hardware description language (HDL). In the proposed design, the pipeline technique is applied at two levels: the overall Scrypt level and the PBKDF2 level. Additionally, the design is divided into several stages to reduce the latency of each clock cycle and increase the operating frequency. The simulation and verification of the design are performed based on Atlys Spartan-6 FPGA Board and Xilinx Virtex-7 FPGA VC707. The performance of the design evaluated on Atlys Spartan-6 has the hash rate of 2209 hashes/s. The maximum operating frequency of the system is 147.059MHz. On Xilinx Virtex-7, the hash rate of the design reaches 5332 hashes/s and the maximum operating frequency reaches 355.051 MHz.

This work presents a comprehensive guide for students and developers who are interested in developing and experimenting with a blockchain technology for cryptocurrencies. Our work allows students to rapidly deploy a new cryptocurrency and provides an accessible way for users to process transactions and mine blocks. A new blockchain can be created using the source code of Litecoin alongside with the Microsoft Azure’s cloud service to deploy the requirements necessary for running the network associated with the blockchain. As Litecoin, we utilize scrypt as the “proof-of-work” algorithm. Built into the codebase for Litecoin, this computationally heavy algorithm is designed to ward off large-scale brute-force attacks, preventing criminals with strong hardware capabilities from bypassing the security measures of the algorithm. This article dives into the intricacies of the steps taken to deploy a new blockchain designed to be used for cryptocurrency.

Implementation of a universal and reliable cloud wallet. This document explains the design, implementation and deployment of a secure Ethereum wallet backed up by a vault of secrets on the cloud. It also introduces key concepts for this task in the field of cryptography and cybersecurity. This project is done in collaboration with the European H2020 i3-Market project. Intelligent, Interoperable, Integrative and deployable open source MARKETplace with trusted and secure software tools for incentivizing the industry data economy. Within this project, the development of a vault of secrets, such as a secure wallet on the cloud, is essential if we desire a trusted data-exchange environment backed up by the blockchain. The developed solution, named Cloud Wallet, consists of three pieces of code, each of which, serves a specific purpose within the complete project: ? Frontend Application (CloudWalletApp) ? Client Library (CloudWalletClient) ? Backend Server (CloudWalletServer) On the one hand, the frontend app allows the user to intuitively create and import Ethereum accounts in order to sign raw messages or Ethereum transactions. While the client takes care of the setup and communication with the server (among others) the app works as a UI wrapper made with the React framework for this client. To sum up, the app manages user interactions, renders the website, and uses CloudWalletClient to manage blockchain and interact with the server. On the other one, CloudWalletServer safely stores an encrypted representation of account credentials so that the client used on the application can rely on a secure credentials cloud backup to restore them back to the client in case of incidences (i.e. lost device). Additionally, it uses Key Derivation Functions to deliberately slow password-check processes and makes them expensive in terms of CPU and memory in order to discourage pre-computation attacks. This project has been developed in conjunction with Alberto Miras Gil with our university and tutor?s approval. Even though we have worked on the same project, while Alberto has focused his work on the Blockchain aspects developed exclusively at the frontend client, I have developed the security aspects of the complete solution, implemented on all frontend app, client and backend server.

Password-hardened encryption (PHE) was introduced by Lai et al. at USENIX 2018 and immediately productized by VirgilSecurity. PHE is a password-based key derivation protocol that involves an oblivious external crypto service for key derivation. The security of PHE protects against offline brute-force attacks, even when the attacker is given the entire database. Furthermore, the crypto service neither learns the derived key nor the password. PHE supports key-rotation meaning that both the server and crypto service can update their keys without involving the user. While PHE significantly strengthens data security, it introduces a single point of failure because key-derivation always requires access to the crypto service. In this work, we address this issue and simultaneously increase security by introducing threshold password-hardened encryption. Our formalization of this primitive revealed shortcomings of the original PHE definition that we also address in this work. Following the spirit of prior works, we give a simple and efficient construction using lightweight tools only. We also implement our construction and evaluate its efficiency. Our experiments confirm the practical efficiency of our scheme and show that it is more efficient than common memory-hard functions, such as scrypt. From a practical perspective this means that threshold PHE can be used as an alternative to scrypt for password protection and key-derivation, offering better security in terms of offline brute force attacks.

We develop an economic model of an offline password cracker which allows us to make quantitative predictions about the fraction of accounts that a rational password attacker would crack in the event of an authentication server breach. We apply our economic model to analyze recent massive password breaches at Yahoo!, Dropbox, LastPass and AshleyMadison. All four organizations were using key-stretching to protect user passwords. In fact, LastPass' use of PBKDF2-SHA256 with $10^5$ hash iterations exceeds 2017 NIST minimum recommendation by an order of magnitude. Nevertheless, our analysis paints a bleak picture: the adopted key-stretching levels provide insufficient protection for user passwords. In particular, we present strong evidence that most user passwords follow a Zipf's law distribution, and characterize the behavior of a rational attacker when user passwords are selected from a Zipf's law distribution. We show that there is a finite threshold which depends on the Zipf's law parameters that characterizes the behavior of a rational attacker -- if the value of a cracked password (normalized by the cost of computing the password hash function) exceeds this threshold then the adversary's optimal strategy is always to continue attacking until each user password has been cracked. In all cases (Yahoo!, Dropbox, LastPass and AshleyMadison) we find that the value of a cracked password almost certainly exceeds this threshold meaning that a rational attacker would crack all passwords that are selected from the Zipf's law distribution (i.e., most user passwords). This prediction holds even if we incorporate an aggressive model of diminishing returns for the attacker (e.g., the total value of $500$ million cracked passwords is less than $100$ times the total value of $5$ million passwords). See paper for full abstract., Comment: IEEE Symposium on Security and Privacy (S&P) 2018

In a traditional DRAM-based main memory architecture, a memory access operation requires much more time and energy than a simple logic operation. This fact is exploited to build time-consuming and power-hungry memory-hard cryptographic functions that serve the purpose of hindering brute-force security attacks.The security of such memory-hard functions depends entirely on the non-trivial costs of memory access. However, various compute-capable memory technologies have recently emerged as promising ways to reduce the memory access bottleneck, yet no one has looked into how they may impact the security of memory-hard cryptographic functions. In this preliminary work, we investigate the impact of near-data-processing (NDP) on scrypt, a widely used memory-hard password-based key-derivation function, and discuss the opportunities to further undermine scrypt using compute-capable memory.

This paper is about a proposal of the algorithm to derive encryption keys based on key-files using the hash algorithm SHA-3. For our upcoming design of block cipher with special key length, which is 111 bytes, we are facing the problem how to derive encryption keys, even there are for example scrypt or Argon2 key-derivation function, we would like to design algorithm specialized for generating hashes of the required length. Thus, we proposed whole new algorithm. We also wanted to forge encryption keys based on key-files and do not limit only for passwords as the source. So, this paper presents the design of the final algorithm and results from testing it. This work is also the first proposal and in the future is planned to test it more.

In cryptocurrency, a block is a record of new transactions that could mean the location of cryptocurrency, medical data, or even voting records. Once each block is completed it’s added to the chain, creating a chain of blocks: a blockchain. Because cryptocurrencies are encrypted, processing any transactions means solving complicated math problems using specified algorithm like SHA256 and Scrypt. People who solve these equations are rewarded with cryptocurrency in a process called mining. In this study the authors will find out the comparison of SHA256 and Scrypt to work on the blockchain. To find out the comparison between SHA256 and Scrypt some test will be done in this research. The test were given to both algorithm on some test System to observe which algorithm that has highest probability in finding new block. the results of the tests done in this paper show that Scrypt is much slower to hash than SHA256 but the Scrypt algorithm has greater chance to find a new block.

Osrednji predmet diplomskega dela je predstaviti zgoščevalne funkcije in algoritme, ki se uporabljajo pri doseganju porazdeljenega soglasja dokaza o delu. Opisana je tehnologija veriženja blokov ter vpliv uporabe posameznih algoritmov na učinkovitost rudarjenja kriptovalut. Predstavljena je primerjava med določenimi izbranimi algoritmi glede na procesorsko moč, ki je potrebna za njihovo izvajanje, zahtevan spominski prostor, hitrost ter druge zahtevnosti, ki so pomembne za te algoritme. Diplomsko delo je omejeno na naslednje algoritme: X11, Cryptonight, Scrypt, SHA-256 in Ethash. The main subject of diploma is to present hash functions and algorithms which are used to achieve distributed consensus based on the proof of work. In the diploma we described the blockchain technology and the influence individual algorithms have on cryptocurrency mining efficiency . A comparison is presented between certain selected algorithms based on the processing power that is required for their implementation, the required memory space, security, speed and other complexities relevant to these algortihms. The diploma is limited to the following hashing algorithms: X11, Cryptonight, Scrypt, SHA-256 and Ethash.

Lack of usability of security Application Programming In- terfaces (APIs) is one of the main reasons for mistakes that programmers make that result in security vulnerabilities in software applications they develop. Especially, APIs that pro- vide cryptographic functionalities such as password hashing are sometimes too complex for programmers to learn and use. To improve the usability of these APIs to make them easy to learn and use, it is important to identify the usability issues exist on those APIs that make those harder to learn and use. In this work, we evaluated the usability of SCrypt password hashing functionality of Bouncycastle API to identify usabil- ity issues in it that persuade programmers to make mistakes while developing applications that would result in security vulnerabilities. We conducted a study with 10 programmers where each of them spent around 2 hours for the study and attempted to develop a secure password storage solution us- ing Bouncycastle API. From data we collected, we identified 63 usability issues that exist in the SCrypt implementation of Bouncycastle API. Results of our study provided useful insights about how security/cryptographic APIs should be designed, developed and improved to provide a better experi- ence for programmers who use them. Furthermore, we expect that this work will provide a guidance on how to conduct usability evaluations for security APIs to identify usability issues exist in them., Comment: 6

The very basic aspect when creating user account systems is to provide protection of data and other details. Hence, there is a need to protect the passwords so that even when the hacker steals the database, the user's passwords are secured using various hashing algorithms. Cryptographic hashing functions like MD5, SHA-216 etc. can be easily hacked with powerful hardware on the hacker’s side. Moreover, these are not slow functions, there is a need for implementation of slow hashing functions along with salt or pepper added, which can withstand the growing technology utilized by the attacker. Generally, these functions are used in Linux/Unix password database for authentication of users and also for other security purposes. The slow hashing functions implemented in this paper are PBKDF2, BCrypt, Scrypt and for cryptanalysis, we have used known-plaintext attack because all the brute-force, dictionary attacks become useless in case of slow hashing functions. So, we are going to implement and analyze the performance of different algorithms and also make comparisons among them.

Password-based key derivation functions (PBKDFs) are commonly used to transform user passwords into keys for symmetric encryption, as well as for user authentication, password hashing, and preventing attacks based on custom hardware. We propose two optimized alternatives that enhance the performance of a previously published PBKDF. This design is based on (1) employing a symmetric cipher, the Advanced Encryption Standard (AES), as a pseudo-random generator and (2) taking advantage of the support for the hardware acceleration for AES that is available on many common platforms in order to mitigate common attacks to password-based user authentication systems. We also analyze their security characteristics, establishing that they are equivalent to the security of the core primitive (AES), and we compare their performance with well-known PBKDF algorithms, such as Scrypt and Argon2, with favorable results. Research partially supported by the Spanish Government under Project Grant TEC2014-54110-R (CASUS).

Cryptographic hash functions have wide applications including password hashing, pricing functions for spam and denial-of-service countermeasures and proof of work in cryptocurrencies. Recent progress on ASIC (Application Specific Integrated Circuit) hash engines raise concerns about the security of the above applications. This leads to a growing interest in ASIC resistant hash function and ASIC resistant proof of work schemes, i.e., those that do not give ASICs a huge advantage. The standard approach towards ASIC resistance today is through memory hard functions or memory hard proof of work schemes. However, we observe that the memory hardness approach is an incomplete solution. It only attempts to provide resistance to an ASIC’s area advantage but overlooks the more important energy advantage. In this paper, we propose the notion of bandwidth hard functions to reduce an ASIC’s energy advantage. CPUs cannot compete with ASICs for energy efficiency in computation, but we can rely on memory accesses to reduce an ASIC’s energy advantage because energy costs of memory accesses are comparable for ASICs and CPUs. We propose a model for hardware energy cost that has sound foundations in practice. We then analyze the bandwidth hardness property of ASIC resistant candidates. We find scrypt, Catena-BRG and Balloon are bandwidth hard with suitable parameters. Lastly, we observe that a capacity hard function is not necessarily bandwidth hard, with a stacked double butterfly graph being a counterexample.

In the paper “On the Complexity of Scrypt and Proofs of Space in the Parallel Random Oracle Model” (Eurocrypt 2016) Joel Alwen et al. focused on proving a lower bound of the complexity of a general problem that underlies both proofs of space protocols [Dziembowski et al. CRYPTO 2015] as well as data-dependent memory-hard functions like \(\mathsf {scrypt}\) — a key-derivation function that is used e.g. as proofs of work in cryptocurrencies like Litecoin.

We present Lyra, a password-based key derivation scheme based on cryptographic sponges. Lyra was designed to be strictly sequential (i.e., not easily parallelizable), providing strong security even against attackers that use multiple processing cores (e.g., custom hardware or a powerful GPU). At the same time, it is very simple to implement in software and allows legitimate users to fine-tune its memory and processing costs according to the desired level of security against brute force password guessing. We compare Lyra with similar-purpose state-of-the-art solutions, showing how our proposal provides a higher security level and overcomes limitations of existing schemes. Specifically, we show that if we fix Lyra ’s total processing time $$t$$ in a legitimate platform, the cost of a memory-free attack against the algorithm is exponential, while the best-known result in the literature (namely, against the scrypt algorithm) is quadratic. In addition, for an identical same processing time, Lyra allows for a higher memory usage than its counterparts, further increasing the cost of brute force attacks.

Hiding memory access patterns is required for secure computation, but remains prohibitively expensive for many interesting applications. Prior work has either developed custom algorithms that minimize the need for data-dependant memory access, or proposed the use of Oblivious RAM (ORAM) to provide a general-purpose solution. However, most ORAMs are designed for client-server scenarios, and provide only asymptotic benefits in secure computation. Even the best prior schemes show concrete benefits over naive linear scan only for array sizes greater than 100. This immediately implies each ORAM access is 100 times slower than a single access at a known location. Even then, prior evaluations ignore the substantial initialization cost of existing schemes. We show how the classical square-root ORAM of Goldreich and Ostrovsky can be modified to overcome these problems, even though it is asymptotically worse than the best known schemes. Specifically, we show a design that has over 100x lower initialization cost, and provides benefits over linear scan for just 8 blocks of data. For all benchmark applications we tried, including Gale-Shapley stable matching and the scrypt key derivation function, our scheme outperforms alternate approaches across a wide range of parameters, often by several orders of magnitude.

We present the Balloon password-hashing algorithm. This is the first practical cryptographic hash function that: (i) has proven memory-hardness properties in the random-oracle model, (ii) uses a password-independent access pattern, and (iii) meets—and often exceeds—the performance of the best heuristically secure password-hashing algorithms. Memory-hard functions require a large amount of working space to evaluate efficiently and, when used for password hashing, they dramatically increase the cost of offline dictionary attacks. In this work, we leverage a previously unstudied property of a certain class of graphs (“random sandwich graphs”) to analyze the memory-hardness of the Balloon algorithm. The techniques we develop are general: we also use them to give a proof of security of the scrypt and Argon2i password-hashing functions, in the random-oracle model. Our security analysis uses a sequential model of computation, which essentially captures attacks that run on single-core machines. Recent work shows how to use massively parallel special-purpose machines (e.g., with hundreds of cores) to attack memory-hard functions, including Balloon. We discuss these important attacks, which are outside of our adversary model, and propose practical defenses against them. To motivate the need for security proofs in the area of password hashing, we demonstrate and implement a practical attack against Argon2i that successfully evaluates the function with less space than was previously claimed possible. Finally, we use experimental results to compare the performance of the Balloon hashing algorithm to other memory-hard functions.

Cryptocurrency, a form of digital currency that has an open and decentralized system and uses cryptography to enhance security and control the creation of new units, is touted to be the next step from conventional monetary transactions. Many cryptocurrencies exist today, with Bitcoin being the most prominent of them. Cryptocurrencies are generated by mining, as a fee for validating any transaction. The rate of generating hashes, which validate any transaction, has been increased by the use of specialized machines such as FPGAs and ASICs, running complex hashing algorithms like SHA-256 and Scrypt, thereby leading to faster generation of cryptocurrencies. This arms race for cheaper-yet-efficient machines has been on since the day the first cryptocurrency, Bitcoin, was introduced in 2009. However, with more people venturing into the world of virtual currency, generating hashes for this validation has become far more complex over the years, with miners having to invest huge sums of money on employing multiple high performance ASICs. Thus the value of the currency obtained for finding a hash did not justify the amount of money spent on setting up the machines, the cooling facilities to overcome the enormous amount of heat they produce and electricity required to run them. The next logical step in this is to utilize the power of cloud computing. Miners leasing super computers that generate hashes at astonishing rates that have a high probability of profits, with the same machine being leased to more than one person on a time bound basis is a win-win situation to both the miners, as well as the cloud service providers. This paper throws light on the nuances of cryptocurrency mining process, the traditional machines used for mining, their limitations, about how cloud based mining is the logical next step and the advantage that cloud platform offers over the traditional machines.

Passwords are still by far the most widely used form of user authentication, for applications ranging from online banking or corporate network access to storage encryption. Password guessing thus poses a serious threat for a multitude of applications. Modern password hashes are specifically designed to slow down guessing attacks. However, having exact measures for the rate of password guessing against determined attackers is non-trivial but important for evaluating the security for many systems. Moreover, such information may be valuable for designing new password hashes, such as in the ongoing password hashing competition (PHC).

Using passwords for user authentication is still the most common method for many internet services and attacks on the password databases pose a severe threat. To reduce this risk, servers store password hashes, which were generated using special password-hashing functions, to slow down guessing attacks. The most frequently used functions of this type are PBKDF2, bcrypt and scrypt. In this paper, we present a novel, flexible, high-speed implementation of a bcrypt password search system on a low-power Xilinx Zynq 7020 FPGA. The design consists of 40 parallel bcrypt cores running at 100 MHz. Our implementation outperforms all currently available implementations and improves password attacks on the same platform by at least 42%, computing 6,511 passwords per second for a cost parameter of 5.

Pattern lock is a mechanism that most of the people set to their Android smart phones. As the built-in pattern lock system adds an extra layer of protection and is one of the innovative unlock methods supported by Android, a fair quantity of study has been done about its (in)security. Pattern locks are not difficult to crack and are vulnerable to precomputation attacks such as brute forcing, dictionaries and rainbow tables. Older versions of Android produce SHA-1 signatures for authentication process which are not salted hashes. However, the newer versions of Android pattern locks utilise scrypt hash function that generates random salt value which needs to be stored in the database to withstand such attacks. But for pattern passwords attaching a salt value is still found not to be enough and susceptible to brute force. This research, therefore, proposes a method where it helps to produce and append a salt value to a password dynamically by representing the pattern using points of an elliptic curve. After the implementation and analysis, the results show this method exhibits strict avalanche criterion and passwords will become more tolerant to brute forcing, and other precomputation attacks which makes it more difficult to compromise.

Most of the common password scramblers hinder password-guessing attacks by “key stretching”, e.g., by iterating a cryptographic hash function many times. With the increasing availability of cheap and massively parallel off-the-shelf hardware, iterating a hash function becomes less and less useful. To defend against attacks based on such hardware, one can exploit their limitations regarding to the amount of fast memory for each single core. The first password scrambler taking this into account was scrypt. In this paper we mount a cache-timing attack on scrypt by exploiting its password-dependent memory-access pattern. Furthermore, we show that it is possible to apply an efficient password filter for scrypt based on a malicious garbage collector. As a remedy, we present a novel password scrambler called Catena which provides both a password-independent memory-access pattern and resistance against garbage-collector attacks. Furthermore, Catena instantiated with the here introduced (G,λ)-DBH operation satisfies a certain time-memory tradeoff called λ-memory-hardness, i.e., using only 1/b the amount of memory, the time necessary to compute the password hash is increased by a factor of b λ . Finally, we introduce a more efficient instantiation of Catena based on a bit-reversal graph.

As more services move on to the web and more people use the cloud for storage of important information, it is important that providers of such services can guarantee that information is kept safe. The most common way of protecting that data is to make it impossible to access without being authenticated as the user owning the data. The most common way for a user to authenticate and thereby becoming authorized to access the data, or service, is by making use of a password. The one trying to safeguard that password must make sure that it is not easy to come by for someone trying to attack the system. The most common way to store a password is by first running that password through a one way function, known as a hash function, that obfuscates it into something that does not at all look related to the password itself. Whenever a user tries to authenticate, they type in their password and it goes through the same function and the results are compared. While this model makes sure that the password is not stored in plain text it contains no way of taking action in case the database of hashed passwords is leaked. Knowing that it is nearly impossible to be fully protected from malevolent users, the ones trying to safe guard information always need to try to make sure that it is difficult to extract information about users' passwords. Since the 70s the password storage has to a large extent looked the same. What is researched and implemented in this thesis is a different way of handling passwords, where the main focus is on making sure there are countermeasures in case the database leaks. The model described and implemented consist of software that make use of the current best practices, with the addition of encrypting the passwords with a symmetric cipher. This is all done in a distributed way to move towards a paradigm where a service provider does not need to rely on one point of security. The end result of this work is a working proof-of-concept software that runs in a distributed manner to derive users' passwords to an obfuscated form. The system is at least as secure as best current practice for storing users passwords but introduces the notion of countermeasures once information has found its way into an adversary's hands.

This article presents a new theoretical framework for computer-assisted decipherment of ancient alphabetic inscriptions. This framework is based on regular expressions, a widely used computer science formalism for encoding text strings with partially unknown characters. We then present a new software called Scrypt, which applies our framework to the Khirbet Qeiyafa ostracon, an important Proto-Canaanite inscription recently discovered in Israel, as a first case study. Several new anthroponymic readings for the Qeiyafa ostracon, found with the help of our software, are presented as part of that case study. The software, freely available online ([www.ScryptApp.com][1]), enables users to encode all possible readings for a given grapheme in the ostracon and provides fast automated dictionary searches for lexemes. [1]: http://www.ScryptApp.com