local saltlen = 20

local oldPE = os.pullEvent
os.pullEvent = os.pullEventRaw
local tx,ty = term.getSize()
local sha256
function buildHasher()
  local MOD = 2^32
  local MODM = MOD-1

  local function memoize(f)
          local mt = {}
          local t = setmetatable({}, mt)
          function mt:__index(k)
                  local v = f(k)
                  t[k] = v
                  return v
          end
          return t
  end

  local function make_bitop_uncached(t, m)
          local function bitop(a, b)
                  local res,p = 0,1
                  while a ~= 0 and b ~= 0 do
                          local am, bm = a % m, b % m
                          res = res + t[am][bm] * p
                          a = (a - am) / m
                          b = (b - bm) / m
                          p = p*m
                  end
                  res = res + (a + b) * p
                  return res
          end
          return bitop
  end

  local function make_bitop(t)
          local op1 = make_bitop_uncached(t,2^1)
          local op2 = memoize(function(a) return memoize(function(b) return op1(a, b) end) end)
          return make_bitop_uncached(op2, 2 ^ (t.n or 1))
  end

  local bxor1 = make_bitop({[0] = {[0] = 0,[1] = 1}, [1] = {[0] = 1, [1] = 0}, n = 4})

  local function bxor(a, b, c, ...)
          local z = nil
          if b then
                  a = a % MOD
                  b = b % MOD
                  z = bxor1(a, b)
                  if c then z = bxor(z, c, ...) end
                  return z
          elseif a then return a % MOD
          else return 0 end
  end

  local function band(a, b, c, ...)
          local z
          if b then
                  a = a % MOD
                  b = b % MOD
                  z = ((a + b) - bxor1(a,b)) / 2
                  if c then z = bit32_band(z, c, ...) end
                  return z
          elseif a then return a % MOD
          else return MODM end
  end

  local function bnot(x) return (-1 - x) % MOD end

  local function rshift1(a, disp)
          if disp < 0 then return lshift(a,-disp) end
          return math.floor(a % 2 ^ 32 / 2 ^ disp)
  end

  local function rshift(x, disp)
          if disp > 31 or disp < -31 then return 0 end
          return rshift1(x % MOD, disp)
  end

  local function lshift(a, disp)
          if disp < 0 then return rshift(a,-disp) end
          return (a * 2 ^ disp) % 2 ^ 32
  end

  local function rrotate(x, disp)
      x = x % MOD
      disp = disp % 32
      local low = band(x, 2 ^ disp - 1)
      return rshift(x, disp) + lshift(low, 32 - disp)
  end

  local k = {
          0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
          0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
          0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
          0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
          0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
          0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
          0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
          0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
          0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
          0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
          0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
          0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
          0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
          0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
          0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
          0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
  }

  local function str2hexa(s)
          return (string.gsub(s, ".", function(c) return string.format("%02x", string.byte(c)) end))
  end

  local function num2s(l, n)
          local s = ""
          for i = 1, n do
                  local rem = l % 256
                  s = string.char(rem) .. s
                  l = (l - rem) / 256
          end
          return s
  end

  local function s232num(s, i)
          local n = 0
          for i = i, i + 3 do n = n*256 + string.byte(s, i) end
          return n
  end

  local function preproc(msg, len)
          local extra = 64 - ((len + 9) % 64)
          len = num2s(8 * len, 8)
          msg = msg .. "\128" .. string.rep("\0", extra) .. len
          assert(#msg % 64 == 0)
          return msg
  end

  local function initH256(H)
          H[1] = 0x6a09e667
          H[2] = 0xbb67ae85
          H[3] = 0x3c6ef372
          H[4] = 0xa54ff53a
          H[5] = 0x510e527f
          H[6] = 0x9b05688c
          H[7] = 0x1f83d9ab
          H[8] = 0x5be0cd19
          return H
  end

  local function digestblock(msg, i, H)
          local w = {}
          for j = 1, 16 do w[j] = s232num(msg, i + (j - 1)*4) end
          for j = 17, 64 do
                  local v = w[j - 15]
                  local s0 = bxor(rrotate(v, 7), rrotate(v, 18), rshift(v, 3))
                  v = w[j - 2]
                  w[j] = w[j - 16] + s0 + w[j - 7] + bxor(rrotate(v, 17), rrotate(v, 19), rshift(v, 10))
          end

          local a, b, c, d, e, f, g, h = H[1], H[2], H[3], H[4], H[5], H[6], H[7], H[8]
          for i = 1, 64 do
                  local s0 = bxor(rrotate(a, 2), rrotate(a, 13), rrotate(a, 22))
                  local maj = bxor(band(a, b), band(a, c), band(b, c))
                  local t2 = s0 + maj
                  local s1 = bxor(rrotate(e, 6), rrotate(e, 11), rrotate(e, 25))
                  local ch = bxor (band(e, f), band(bnot(e), g))
                  local t1 = h + s1 + ch + k[i] + w[i]
                  h, g, f, e, d, c, b, a = g, f, e, d + t1, c, b, a, t1 + t2
          end

          H[1] = band(H[1] + a)
          H[2] = band(H[2] + b)
          H[3] = band(H[3] + c)
          H[4] = band(H[4] + d)
          H[5] = band(H[5] + e)
          H[6] = band(H[6] + f)
          H[7] = band(H[7] + g)
          H[8] = band(H[8] + h)
  end

  sha256 = function(msg)
          msg = preproc(msg, #msg)
          local H = initH256({})
          for i = 1, #msg, 64 do digestblock(msg, i, H) end
          return str2hexa(num2s(H[1], 4) .. num2s(H[2], 4) .. num2s(H[3], 4) .. num2s(H[4], 4) ..
                  num2s(H[5], 4) .. num2s(H[6], 4) .. num2s(H[7], 4) .. num2s(H[8], 4))
  end
end
buildHasher()

function limitRead( nlim, cOverlay)
  cOverlay=cOverlay or nil
  local px,py = term.getCursorPos()
  local txt = ""
  local boxOffset = 0
  local strPos = 1
  term.setCursorBlink(true)
  while true do
    e,p1 = os.pullEvent()
    if e=="key" then
      local key = p1
      if key==keys.left then
        if strPos>1 then
          strPos=strPos-1
          if strPos-boxOffset==0 then
            boxOffset=boxOffset-1
          end
        end
      elseif key==keys.right then
        if strPos<=#txt then
          strPos=strPos+1
          if strPos-boxOffset>nlim then
            boxOffset=boxOffset+1
          end
        end
      elseif key==keys.enter then
        break
      elseif key==keys.backspace then
        if strPos~=1 then
          txt=txt:sub(1,strPos-2)..txt:sub(strPos,#txt)
          strPos=strPos-1
          if strPos-boxOffset==0 then
            boxOffset=boxOffset-1
          end
        end
      elseif key==keys.delete then
        if strPos-1~=#txt then
          txt=txt:sub(1,strPos-1)..txt:sub(strPos+1,#txt)
        end
      end
    elseif e=="char" then
      txt = txt:sub(1,strPos-1)..p1..txt:sub(strPos,#txt)
      strPos=strPos+1
      if strPos-1-boxOffset>=nlim then
        boxOffset=boxOffset+1
      end
    end
    term.setCursorPos(px,py)
    write(string.rep(" ",nlim))
    term.setCursorPos(px,py)

    --print(cOverlay==nil and "Yep" or "Nope")
    --read()
    if cOverlay==nil then
    --  term.setTextColor(colors.white)
      write(txt:sub(boxOffset+1,boxOffset+nlim))
    --  write(txt)
    else
      write(string.rep(cOverlay,#txt):sub(boxOffset+1,nlim+boxOffset))
    end
    term.setCursorPos(px+strPos-1-boxOffset,py)
  end
  term.setCursorBlink(false)
  return txt
end




local tvals = {
  BMenu = {
    "Password Change",
    "New Password: "
  },
  PScrn = {
    "This computer is password protected.",
    "Password: "
  },
}

local function generateSalt()
  local ref = "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
  local str = ""
  for i=1,saltlen do
    local pos = math.random(1,#ref)
    str = str..ref:sub(pos,pos)
  end
  return str
end

local tColors = {
  backGround = colors.cyan,
  textColor = colors.black,
}

local function runPassword()
  local file = fs.open(".pass","r")
  if file then
    local pass = file.readLine()
    local sfile = fs.open(".salt","r")
    local salt = sfile.readLine()
  if pass == nil then
    return false
  end
    sfile.close()
    file.close()
    --term.setBackgroundColor(colors.cyan)
    --term.setTextColor(colors.black)
    term.clear()
    term.setCursorPos(tx/2+1-#tvals.PScrn[1]/2,2)
    term.write("This computer is password protected.")
    term.setCursorPos(tx/2+1-#tvals.PScrn[2]/2,5)
    term.write("Password: ")
    term.setCursorPos(3,6)
    --term.setBackgroundColor(colors.lightGray)
    term.write(string.rep(" ",tx-4))
    term.setCursorPos(3,6)
    local inp = limitRead(tx-4,"*")
    if sha256(inp..salt) == pass then
   graphics()
      return true
    else
        return false
    end
  else
    graphics()
  end
end

local function drawCentered(txt, y)
  term.setCursorPos(tx/2+1-#txt/2,y)
  term.write(txt)
end


--term.setBackgroundColor(colors.black)
--term.setTextColor(colors.yellow)
--term.clear()
--term.setCursorPos(1,1)
--print("Press any key to enter BIOS menu...")
--os.startTimer(1)
--local e = os.pullEvent()

--if e == "key" then
function graphics()
  --term.setBackgroundColor(colors.cyan)
  --term.setTextColor(colors.black)
  term.clear()
  local sel = 1
  local mno = {
    ["Change Password"] = function()
      --term.setBackgroundColor(colors.cyan)
      --term.setTextColor(colors.black)
      term.clear()
      term.setCursorPos(tx/2+1-#tvals.BMenu[1]/2,2)
      term.write(tvals.BMenu[1])
      term.setCursorPos(tx/2+1-#tvals.BMenu[2]/2,5)
      term.write("New Password: ")
      term.setCursorPos(3,6)
      --term.setBackgroundColor(colors.lightGray)
      term.write(string.rep(" ",tx-4))
      term.setCursorPos(3,6)
      local inp = limitRead(tx-4,"*")
      local slt = generateSalt()
      local pfile = fs.open(".pass","w")
      local sfile = fs.open(".salt","w")
      pfile.write(sha256(inp..slt))
      sfile.write(slt)
      pfile.close()
      sfile.close()
    end,
    ["Remove Password"] = function()
      --term.setBackgroundColor(colors.cyan)
      --term.setTextColor(colors.black)
      term.clear()
      drawCentered("Are you sure? (y/n)",ty/2)
      while true do
        local e,k = os.pullEvent("key")
        if e=="key" then
          if k==keys.y then
            if fs.exists(".pass") then
              local t = fs.open(".pass","w")
       t.close()
            end
            if fs.exists(".salt") then
              local t = fs.open(".salt","w")
       t.close()
            end
            break
          elseif k==keys.n then
            break
          end
        end
      end
    end,
    ["Exit"] = function()
   if not ((fs.exists(".pass")) and (fs.exists(".salt"))) then
    local t = fs.open(".pass","w")
    t.close()
    local t= fs.open(".salt","w")
    t.close()
   end
      return "exit"
    end
  }
  local order = { ["Change Password"]=1,["Remove Password"]=2,["Exit"]=3 }
  local fns = {}
  for k,v in pairs(mno) do
    fns[order[k]]=v
  end
  while true do
    --term.setBackgroundColor(colors.cyan)
    --term.setTextColor(colors.black)
    term.clear()
    for k,v in pairs(mno) do
      if order[k]==sel then
        drawCentered("> "..k.." <",order[k]+2)
      else
          drawCentered(k,order[k]+2)
      end
    end
    --term.setBackgroundColor(colors.lightGray)
    term.setCursorPos(1,1)
    term.write(string.rep(" ",tx))
    drawCentered("BIOS Menu",1)
    local e,p1,p2,p3,p4,p5 = os.pullEvent()
    if e=="key" then
      local key = p1
      if key==keys.enter then
        local result = fns[sel]()
        if result == "exit" then
          break
        end
      elseif key==keys.up then
        sel = sel-1
        if sel<1 then
          sel = #fns
        end
      elseif key==keys.down then
        sel = sel+1
        if sel>#fns then
          sel = 1
        end
      end
    end
  end
end
if fs.exists(".salt") or fs.exists(".pass") then
  runPassword()
else
  graphics()
end
if not fs.exists(".salt") then
  local temp = fs.open(".salt","w")
  temp.close()
end
if not fs.exists(".pass") then
  local temp = fs.open(".pass","w")
  temp.close()
end


--term.setBackgroundColor(colors.black)
--term.setTextColor(colors.white)
term.setCursorPos(1,1)
term.clear()
os.pullEvent = oldPE

local _resolveProgram = shell.resolveProgram
local rawget          = _G.rawget

local blockedPaths = {}

-- Paths that cannot be opened for writing,
-- deleting, moving, or copying.
blockedPaths[_resolveProgram ("/.pass")] = true
blockedPaths[_resolveProgram ("/.salt")]   = true
--blockedPaths[_resolveProgram ("/pass")]   = true
blockedPaths[_resolveProgram ("/rom/autorun/password")]   = true

local _fs = {
  -- Don't want to be able to delete
  -- or edit the contents.
  open   = _G.fs.open,
  delete = _G.fs.delete,
  move   = _G.fs.move,
  copy   = _G.fs.copy
}

local function resolveProgram (path)
  local pass, _error = pcall (rawget, path)

  if not pass then
    return _resolveProgram (path)
  end
end

-- Replace global fs functions with
-- protected ones.
for name, func in pairs (_fs) do
  _G.fs[name] = function (path, ...)
    path = resolveProgram (path)

    if blockedPaths[path] then
      printError ("Cannont access " .. path .. "!")
    else
      return func (path, ...)
    end
  end
end

--[[ Prevent metatable penetration of resolveProgram.
local function resolveProgram (path)
  local pass, _error = pcall (rawget, path)

  -- This is kind of sketchy.
  -- It only checks if rawget fails, meaning
  -- that the 'path' value wasn't a table.
  -- Should work, though; if 'path' wasn't a table,
  -- then it can't have a metatable.
  if not pass then
    return _resolveProgram (path)
  end
end]]