Podcast: The Hearing – Doug Pepe – Partner – Joseph Hage Aaronson LLC

From the producer: You may have watched as Mark Zuckerberg explained the internet to Congress in a way that felt a bit unnecessary. Well, this episode is sort of the opposite of that. Joe Raczynski is joined by legal and mathematical macroeconomics genius Doug Pepe, to take us through blockchain, tokens and cryptocurrency in a way that’s genuinely enlightening.

The legal industry is sometimes accused of not keeping up, but we know that’s not true. Lawyers are occupying this space now. Their clients are very active and they have a crucial role to play in the serious policy issues being debated.

Doug, a partner at Joseph Hage Aaronson, started his blockchain journey by building gaming computers with his young children, and then teaching them how to mine bitcoin. Fast forward and Doug is now an expert on blockchain privacy, smart contracts and digital identity.

Apple: https://podcasts.apple.com/us/podcast/ep-68-doug-pepe-jha/id1389813956?i=1000503066806

Google/Android: https://podcasts.google.com/feed/aHR0cHM6Ly9wb3J0YWwtYXBpLnRoaXNpc2Rpc3RvcnRlZC5jb20veG1sL3RoZS1oZWFyaW5n/episode/aHR0cDovL2F1ZGlvLnRoaXNpc2Rpc3RvcnRlZC5jb20vcmVwb3NpdG9yeS9hdWRpby9lcGlzb2Rlcy9FcDY4X0RvdWdfUGVwZV9taXhkb3duLTE2MDgzMDQxMDgzMzgzNDc3MDctTXpFMk9UVXROelF6TVRNME16WT0ubXAz?sa=X&ved=0CAUQkfYCahcKEwjo-ObCpN_tAhUAAAAAHQAAAAAQAw

Find out more at tr.com/TheHearing

Podcast: The Hearing With Kevin Poulter & Joseph Raczynski – Future Legal

Episode 2 of THE HEARING is now live!

In episode 2 of The Hearing Podcast Kevin Poulter speaks to futurist Joseph Raczynski on #legaltech #AI #blockchain and the future of the robot lawyer.

Listen now and subscribe to #thehearingpodcast on:

iTunes – https://tmsnrt.rs/2swyzmz

Spotify – https://tmsnrt.rs/2kOOpVw

SoundCloud – https://tmsnrt.rs/2Js4deI

Podcast: The Technology of Blockchain & Cryptocurrencies with Judith Alison Lee of Gibson Dunn (Part 2)

Originally published in the Legal Executive Institute.

By Joseph Raczynski, Gregg Wirth, and Judith Alison Lee

In the second part of our podcast on the technology behind blockchain and cryptocurrencies like Bitcoin, I speak with Judith Alison Lee, a partner in the Washington, D.C. office of Gibson Dunn & Crutcher and Co-Chair of the firm’s International Trade Practice Group.

Gibson Dunn

Judith Alison Lee of Gibson Dunn & Crutcher

Among her other areas of expertise, Ms. Lee advises clients on issues relating to virtual and digital currencies and related blockchain technologies.


How to Launch an ICO Token on Ethereum in 90 Minutes

By Joseph Raczynski

So you want to have your own cryptocurrency, eh?  It is surprisingly not too cumbersome to create.  If you have some very basic coding skills, general understand of a digital wallet, and the ability to follow point by point instructions, this should take about 90 minutes.  I will guide you through the process of launching your own token to fund your company, or more than likely simply test how to create an Ethereum (ERC20) token.  I am not responsible for anything that comes from your use of this code or the outlined process.  Use at your own risk.

Recently I was asked to put together a more formal booklet on how someone could technically launch an ICO (Initial Coin Offering) in order to create a blockchain enabled cryptocurrency.  I wrote up all of the various components and loads of caveats around all of the considerations.  In order to do this properly, you should have a full blown business plan, marketing master plan, have sought legal compliance, and a whole host of other services.  To that end, there is a new cottage industry surrounding taking companies through the ICO process.  ICO Box is one such company that specializes in this end to end consulting.

For the sake of this guide, I will walk you through all of the steps to create your first token for your project right here.  Some context, I based this off of my upcoming ICO for DC WiFi as the example.

Part 1: You will need the following:

  • Buy some ETH (if you are new to this, buy it from Coinbase)
  • A text editor for your code modification (Open a Text file on Windows)
  • Download a digital wallet (MetaMask)
  • Easy Compilier (via the web Solidity Remix IDE Compiler)

Part 2: Business Decisions

You shockingly need very little to get started with your token creation.  You will need four pieces of information;  1) Name of the Token, 2) Token Symbol (like a stock ticker), 3) The Token Decimal Places (making the token divisible), and 4) The total number of tokens in circulation.

In short:

  1. Number of Tokens You Will Assume (Will be all of the coins initially)
  2. Total Tokens in Circulation (ranges from 10,000 to 1,000,000,000)
  3. Name of the Token
  4. Token Decimal Places (usually 18 places)
  5. Token Symbol (use three or four letters)

My real example: (see live)

  1. Number of Tokens You Will Assume = 1,000,000,000
  2. Total Tokens in Circulation = 1,000,000,000
  3. Name of the Token = The Joerazz Crypto Token of Greatness 
  4. Token Decimal Places = 18
  5. Token Symbol = JoRa

Part 3: The Contract Coding

Now that you know the basics, copy and paste all of the code below into your your code editor, or a text document.  Simply focus on changing the five facets from above in the red section of code below. 

pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant returns (uint256 balance) {}

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}

    /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of wei to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) returns (bool success) {}

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
}

contract StandardToken is Token {

    function transfer(address _to, uint256 _value) returns (bool success) {
        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[msg.sender] >= _value && _value > 0) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            Transfer(msg.sender, _to, _value);
            return true;
        } else { return false; }
    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            return true;
        } else { return false; }
    }

    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
    uint256 public totalSupply;
}


//name this contract whatever you'd like
contract ERC20Token is StandardToken {

    function () {
        //if ether is sent to this address, send it back.
        throw;
    }

    /* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 //An identifier: eg SBX
    string public version = 'H1.0';       //human 0.1 standard. Just an arbitrary versioning scheme.

//
// THIS IS WHAT YOU NEED TO DO - CHANGE THE BELOW TO REFLECT YOUR CHOICES FROM WHAT YOU CHOOSE ABOVE IN RED
//

//make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token

    function ERC20Token(
        ) {
        balances[msg.sender] = NUMBER_OF_TOKENS_HERE;               // Give the creator all initial tokens (100000 for example)
        totalSupply = NUMBER_OF_TOKENS_HERE;                        // Update total supply (100000 for example)
        name = "NAME OF YOUR TOKEN HERE";                                   // Set the name for display purposes
        decimals = 0;                            // Amount of decimals for display purposes
        symbol = "SYM";                               // Set the symbol for display purposes
    }

    /* Approves and then calls the receiving contract */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);

        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
        return true;
    }
}

This code is from the good people at Code-Factory.  You can see if they have any newer code here. The above code is displayed in three parts, combined into one section for ease here.  The code is from February of 2017, v 0.4.4.

When you are filling in the four fields, one funky aspect that you will want to pay attention to is the decimal portion.  Examples: If I wish to create 1,000,000,000 billion tokens and I want 18 decimal points, then I have to add 18 zeros onto the 1 billion number.  This number is added to two fields in your code.  So for 1 billion coins with 18 decimals point would look like 1000000000000000000000000000 and do not add commas to your code.  Another example, if you do not want any decimal points then you would not add any extra zeros.  Last example on this, if you want 8 decimal points, you would add 8 zeros to the 1,000,000,000 billion so it would look like 100000000000000000.  Most cryptocurrencies have 18 decimals.

  • Number of Tokens You Will Assume = 1000000000000000000000000000
  • Total Tokens in Circulation = 1000000000000000000000000000

Part 4: Testing via Ropsten Test Net

It is time to take your modified code – all four lines – and test it out.  You could test this in Ethereum’s live environment, but that would be a waste of money (a few dollars up to $8) for each time it doesn’t work.  So make sure you are on the TestNet of Metamask.

Download MetaMask Chrome plugin.  This is a digital wallet which can store Ethereum bmetamaskased tokens (ERC20), like the one you are going to make.  You can also deploy smart contracts via this robust little app.  MyEtherWallet, is also another option, but for this overview, I am using MetaMask for ease.

 

 

 

When you create any digital wallet, the seed (a bunch of random words) is something that you will want to take the utmost care around securing.  If you lose these words (essentially your password) you will lose complete access to your wallet on the blockchain and there is no way to recover this – none.  So keep it safe and secure – preferably offline.

The next step is to drop your doctored code into a compiler, which reviews the code for errors, identifies code that could be better defined, and then publishes that code directly to Ethereum’s blockchain.  Click on Solidity Remix IDE Compiler and copy and paste the code you modified in your text editor into the compiler.

Open your MetaMask wallet, which should be a tiny icon on the upper right corner of Chrome.  When it is open, make sure you change the network to “Ropsten TestNet” by clicking the little arrow.

testnet

Once you do this, you will need to add fake ETH to the TestNet.  Since this is a test network, you get free fake ETH from the network, but you have to request it.  If you don’t have any of the foe ETH, you will not be able to send your contract to the blockchain.

code

If you get a bunch of yellow errors in the right panel, don’t worry, these are cautionary and not fatal.  It may look like this.  Again, it should pose any problems.

errors

Next you will need to go to the actual version of the compilier and make sure you are not using a “nightly” version.  It defaults to the correct version for me, but just make sure it does not say “nightly”.  The arrow drop down is where you can change the version, if necessary.  Make sure you write down which version you choose, as you will need this later.

version

Now head back to to the “Run” tab on the same screen and click “Create”.  What is fascinating is that the compiler automatically connects to your MetaMask Wallet in your browser to create the contract.  As previously mentioned, more then likely the first time you do this you will have to request or add fake ETH to the TestNet.  Since this is a test network, you get free fake ETH from the network, but you have to request it.  If you don’t have any of the foe ETH, you will not be able to send your contract to the blockchain.  This sometimes take a bit of finagling.

So below, click “create” and the MetaMask wallet will pop up over your browser.  As mentioned, if you don’t have any fake ETH, will ask you to generate them – request 1 ETH.

run

Click “Submit” to generate the contract.

confirmcontract

Now click on the date listed below and it will take you to the live generation of the contract via Etherscan.

wallet confirm

If all went well, you will see something like the below.  A green check is great.

success

If you made it this far, now it’s time to load your tokens into your wallet.

Part 5: Loading New Token in Your Wallet

contract

Grab (copy) your contract address which will be different than what you see above and go to MetaMask.  Click “Add Token”

tokenadd

You should see the following where you enter your Contract Address which you copied from Etherscan.  Also add the Token Symbol and Decimals and click “Add”.

token18

There you go!  It should be added to the list.  I have 1 billion JORA tokens now.

listoftokens

Part 6: Verify Your Code

One item, which is not essential, but shows that you are not too shady is verifying the code you used.

On the Etherscan page, where you have the contract ID, click on that link.

contract

Then on the following page look for the “Contract Code” tab and click “Verify And Publish”

proof

The next screen will look like this with the contract ID already populated.  You need to fill in the “Contract Name” with “ERC20TOKEN”, then select the correct “Compilier” – make sure it is the same version you wrote down earlier which is not the “nightly” and change “Optimization” to “No”.  Then copy and paste the whole section of code from the compilier into the big text box.  Forget all of the other parts and click “Verify” at the very bottom of the page.

verify2

Now if that all worked, you should get the following:

finalconfirm

If that all worked, you are good to go!  The next part is actually doing on the real official Ethereum blockchain.

Part 7: Launch Your Token on Prod

Now simply go through the same process by on the live Main Network site.  So go to MetaMask and hit the drop-down box and change it to “Main Network”.

mainnet

Now go through Part 4 – 8.  You will need ETH for this final stage.

Part 8: Verification:

If you want to be verified, look to do so by filling in the following information on Etherscan.  This is vetted by the organization so you do need this to be approved for this portion.

To update your ERC20 token information please provide us with the following information:

Firstly, check that your token contract source code has been verified.

1. Contract Address: 0xd5XXXXXXXXXXXXXXXXXXXXXXXXX

2. Official Site URL:

3. Link to download a 28x28png icon logo:

4. Official Contact Email Address:

5. Link to blog (optional):

6. Link to reddit (optional):

7. Link to slack (optional):

8. Link to facebook (optional):

9. Link to twitter (optional):

10. Link to bitcointalk (optional):

11. Link to github (optional):

12. Link to telegram (optional):

13. Link to whitepaper (optional):

14. CoinMarketCap Link (PriceData):

 

That is it!  Please let me know how this goes for you.

 

 

Reference @maxnachamkin

 

 

 

 

 

ILTACON 2016: When Will Blockchain and Smart Contracts Be Important in Legal?

By Joseph Raczynski

“Blockchain is Hot: More than $1.5 Billion has Been Invested in Blockchain in the Last 18 Months”

  • Tori Adams, Booz Allen Hamilton

 

NATIONAL HARBOR, Md. — If someone had told you in 1993 that the Web would be integral to your life today, would you have believed them? Well, the discussion around blockchain technology at ILTACON 2016 harkened back to that same scenario of the early ‘90s. This is a reboot, where another new technology will revolutionize the world.

Moderated by the esteemed Ron Friedmann, Partner at Fireman & Company, we were led down the path of what to expect with blockchain. Rohit Talwar, CEO of Fast Future Research, started us off with his futuristic vision on what we can expect over the next five years. Joe Dewey, Partner at Holland & Knight, who specializes in blockchain, discussed the law and smart contracts. Lastly, Tori Adams, a data scientist at Booz Allen Hamilton, illustrated her predictions on the reality of this technology in the near term.

Current Landscape

All major industries are looking toward blockchain — most pointedly, the financial sector. Talwar focused on one platform that is pushing this new space forward quickly — Ethereum — a pseudo-Bitcoin 2.0 that allows users to code on top of the blockchain. This can create huge advances in how the blockchain can interact with the world; utlizing smart contracts and digital identities, an even executing stock trades. In fact, Talwar stated that Goldman Sachs estimated a legal savings of $11 billion to $12 billion per year from streamlining clearing and settlement of cash and securities through such technology.

Near Future

The next significant phase developing now is the DAO (Decentralized Autonomous Organizations) which means that processes and companies are completely autonomous. This technology has the ability to disrupt a disrupter, e.g. Airbnb. Let’s say you visit a DAO-enabled travel site. The condo owner places an ad on the site to rent their place weekly. You choose their place in Miami, agree to the terms (date of check-in and -out, etc.) and agree to the fee and deposit (paid automatically). When you arrive at the condo to check-in, simply enter the password at the door through an Internet of Things (IoT) tech-enabled doorknob (check out Slock.it) and you gain access. That lock at the front door knows who you are and how much you paid, and it can also see your contract for the rental of the condo and knows when you are to be out. The DAO can do all of this with one employee running the entire operation.

Law Firms Start to Embrace Blockchain

Several law firms are starting to make a foray into this space. Recently Steptoe & Johnson began a multi-disciplinarian practice to help manage the blockchain for clients. They will also be accepting Bitcoin as payment. Most importantly, they co-founded the Blockchain Alliance6, a coalition of 25 blockchain companies and 25 regulatory and law enforcement agencies — including Interpol, Europol, the Securities and Exchange Commission (SEC) and the FBI — to educate enforcement agencies about digital currencies and blockchain technology. Other law firms including Holland & Knight see exponential growth of attorneys laboring in this discipline.

Smart Contracts

Holland & Knight’s Dewey said he believes the definition around smart contracts can be varied. For the purposes of this conversation, it is snippets of code that can change the ledger or a legal contract that is implemented on the blockchain. Of course, he outlined several benefits and challenges to this new innovation in the area of smart contracts:

Benefits:

  • Smart contracts are coded so there is less ambiguity than prose;
  • Verification can be achieved even within a trustless environment;
  • Self-executing; so once released, it is difficult to impede execution; and
  • Integrates well with IoT, artificial intelligence (AI) and machine learning.

Challenges:

  • Must balance transparency with privacy concerns;
  • Infrastructure needs to be updated;
  • Lack of experience with blockchain technology in IT departments;
  • Lack of education and understanding of the technology in other departments, including compliance;
  • Development of uniform standards and protocols; and (of course)
  • Need to overcoming custom and tradition (e., change is hard.)

So a real world example of how a smart contract was implemented can be seen in how Barclays did it with an interest rate swap prototype. Essentially, the investment bank set up an incubator of coders who worked with their legal department to understand how these swaps (trades) worked legally. They distilled three lines in the process that could be coded — (x) the amount of cash; (y) the interest rate; and (z) the currency. Once this information was garnered, the transaction could be solidified and then stored on a blockchain.

One of the most surprising revelations of the session came from Dewey when he stated: “Big news for attorneys, existing law — passed well before blockchain technology was contemplated —not only validates transactions, including the trading of credit interests accomplished through the use of the technology we are discussing, but as a matter of policy, strongly supports it.”

There is little question that this is an industry that will be growing rapidly over the next few years. Many firms are moving forward with practice areas and educating their attorneys on the technology to better position themselves for the coming wave.

Lastly, Dewey added some additional encouraging words surrounding the future of blockchain. In May, the State of Delaware — which is home to almost two-thirds of the Fortune 500 companies — announced a Blockchain Initiative so that corporate filings can be added to the ledger. “This is a clear sign that blockchain technology will have a significant impact on business,” he said.

Law Firm and Corporate Cybersecruity Presentation – UMB

By Joseph Raczynski

Recorded at the University of Maryland, Baltimore during the “Cybersecruity and You” morning session. Discussed is the current landscape of cybersecurity at law firms and corporations, the primary issues these organizations are finding and general awareness of what is happening.

Blockchain White Paper

By Joseph Raczynski

Abstract: This white paper discusses the history, inner workings and applications of blockchain, an online public ledgering system, and how it will soon significantly impact many aspects of the legal industry. The first part of this paper will show the marvels and the pitfalls of Bitcoin and its underlining blockchain technology. The second part will describe what full global adoption of a cryptocurrency and blockchain technology would entail. And the third will explain the potential legal implications of blockchain technology.

LegalSEC: Shedding Light on the Dark Net 

By Joseph Raczynski

The importance of law firms understanding the dark web

Your very sensitive private client data could be available for all to see on the Internet right now.  Technically this data would be on the Dark Net or Dark Web.  It is the portion of the World Wide Web that is hidden or inaccessible from normal browsers.  As corporations and law firms grapple with larger and more profound attacks, I think it is important to be aware of how individuals access it and what occurs there to better safeguard your firm from what is happening now.  At the cybersecurity LegalSEC Summit last week in Baltimore, Kevin Lancaster CEO of Winvale, Todd Nielson, President at ‎Secuvant Cyber Security, and Will Nuland, Sr. Security Researcher at Dell SecureWorks, spoke about the nuances around the Dark Net.

The Dark Web, born from a United States government program had positive intent from the onset.  It created a cyberspace where people in disaffected regions could anonymously visit and share ideas freely.  North Koreans and Iranians use this to congregate and postulate new ways to live.  They could then visit this space in the ether and share ideas freely without the fear that they would be persecuted for espousing ideas incongruous with their government point of view.

How to get there:

The following is not advised, but is here as an awareness of how people access the Dark Web.

Mozilla Firefox has a plugin (Tor Project), a simple free application run by a nonprofit organization which turns your normal browser into a Tor Onion enabled browser.  What that means is that the plugin creates a tunneled Internet to a minimum of 100 other locations around the world.  You are essentially establishing a proxy connection to other computers who are running the same Tor software.  This establishes a very strong sense of anonymity and security that no one knows who you are or where you live (IP address).   If I live in Washington, DC after running the plugin I may show up as living in Prague, but first being routed through 99 other cities.

darkweb

Once the application is launched you would need to find an index page, like the Hidden Wiki, which gives users a general launching off point for perusing the Dark Web websites.  It is not a pure search and find environment like Google, though some sites are indexed.  Sites are not set up with URL structure like we have on the Open Web, http://www.thomsonreuters.com.  In fact they appear to be hashed with letters and numbers in a random pattern.  They also end in an .onion compared to the normal .com that we tend to see.  So an example address might be: ijfije856ya5lo.onion.

Once there:

Unfortunately, once a user passes into this realm, there is a minefield awaiting.  The Wiki page starts with the benign and dives headlong into the frightening and disturbing.  You can buy $10,000 of fake US dollars for the equivalent of $5,000 in Bitcoin, the currency of choice.  The cryptocurrency Bitcoin is also generally considered anonymous.   Other possibilities include, hiring a hacker, buying prescription drugs, and buying illegal drugs, and acquiring arms or if you so desired, get involved in unregulated medical trials.  On the darker side, you can even hire a hit man.

Law Firm Perspective on Dark Web:

The key important piece to this post is that law firms are now being brought into the dark side.  Criminals are stealing IP information, M&A information and dropping off onto the Dark Web.  Other groups are grabbing proprietary information or sensitive client information from law firm networks and saving it onto the Dark Net to either expose the firm, or to hold at ransom.  Hackers for hire have been used to target corporations and law firms.

One of the subjects that was asked of the panel, how should firms handle the Dark Web?   In my time consulting around this subject, I was curious about the response.  The group was split.  Some thought that companies should not use their own networks to access the environment, others stated that in a controlled access situation, they could monitor what is going on the Dark Web to protect their brand.  In fact, it was stated that nearly two million people a day visit, but most are monitoring what is happening.  Law firms and corporations should be looking for client names, login and passwords, email address of their respective company.

With the increase in cyber-attacks, all entities have to be aware of how the hackers operate.  Understanding the Dark Web in the context of this is part of the due diligence for any corporation or law firm today.  Fortunately a new wave of companies are surfacing which can monitor the Dark Net on behalf of your organization.