public ActionResult StreamSource(string shortenedUrl, string password) { if (shortenedUrl.Length > 5) { var mapping = _context.CustomMapping.Find(Base62.Decode(shortenedUrl)); if (password != mapping.Password) { return(BadRequest()); } else { return(PhysicalFile(mapping.Original, "application/octet-stream", true)); } } else { var mapping = _context.Mapping.Find(Base62.Decode(shortenedUrl)); if (password != mapping.Password) { return(BadRequest()); } else { return(PhysicalFile(mapping.Original, "application/octet-stream", true)); } } }
public IActionResult OnPost(string shortenedUrl, string password) { if (shortenedUrl.Length > 5) { var mapping = _context.CustomMapping.Find(Base62.Decode(shortenedUrl)); if (password != mapping.Password) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } else { VideoSource = "/StreamSource?shortenedUrl=" + shortenedUrl + "password="******"video/" + mapping.Original.Split(".").Last(); return(Page()); } } else { var mapping = _context.Mapping.Find(Base62.Decode(shortenedUrl)); if (password != mapping.Password) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } else { VideoSource = "/StreamSource?shortenedUrl=" + shortenedUrl + "&password="******"video/" + mapping.Original.Split(".").Last(); return(Page()); } } }
public async Task <ActionResult> Index(LoginViewModel model) { using (var hash = SHA256.Create()) { if (!ModelState.IsValid) { return(View(model)); } var result = await _signinManager.Value.PasswordSignInAsync( Base62.Encode(hash.ComputeHash(Encoding.UTF8.GetBytes(model.Email))), model.Password, false, false); switch (result) { case SignInStatus.LockedOut: case SignInStatus.RequiresVerification: throw new NotImplementedException(); case SignInStatus.Success: return(RedirectToRoute("Default")); case SignInStatus.Failure: ModelState.AddModelError("", "Username or password was incorrect."); model.Password = ""; return(View(model)); default: throw new NotImplementedException(); } } }
public async Task <IActionResult> ShortUrlAsync(string base62, CancellationToken token) { if (string.IsNullOrEmpty(base62)) { return(NotFound()); } //if (!long.TryParse(base62, out var id)) //{ if (!Base62.TryParse(base62, out var id)) { return(NotFound()); } _userManager.TryGetLongUserId(User, out var userId); var query = new DocumentById(id, userId); var model = await _queryBus.QueryAsync(query, token); if (model == null) { return(NotFound()); } var t = RedirectToRoutePermanent(SeoTypeString.Document, new { courseName = FriendlyUrlHelper.GetFriendlyTitle(model.Document.Course), id = id.Value, name = FriendlyUrlHelper.GetFriendlyTitle(model.Document.Title) }); return(t); }
public IActionResult OnPost(string shortenedUrl, string password) { if (shortenedUrl.Length > 5) { var mapping = _context.CustomMapping.Find(Base62.Decode(shortenedUrl)); if (password != mapping.Password) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } else { ImageBase64String = "data:image/" + Path.GetExtension(mapping.Original).Substring(1) + ";base64," + Extension.ConvertToBase64(new FileStream(mapping.Original, FileMode.Open, FileAccess.Read)); return(Page()); } } else { var mapping = _context.Mapping.Find(Base62.Decode(shortenedUrl)); if (password != mapping.Password) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } else { ImageBase64String = "data:image/" + Path.GetExtension(mapping.Original).Substring(1) + ";base64," + Extension.ConvertToBase64(new FileStream(mapping.Original, FileMode.Open, FileAccess.Read)); return(Page()); } } }
public void FromBase62Chars11_WithOverlappingInputAndOutputSpans_ShouldReturnExpectedOutput(string text, string base62String) { Span <byte> bytes = stackalloc byte[11]; System.Text.Encoding.UTF8.GetBytes(base62String, bytes); Base62.FromBase62Chars11(bytes, bytes); var originalString = System.Text.Encoding.UTF8.GetString(bytes[..8]);
public ActionResult OnGet(string shortenedUrl) { if (shortenedUrl.Length > 5) { var mapping = _context.CustomMapping.Find(Base62.Decode(shortenedUrl)); if (!string.IsNullOrWhiteSpace(mapping.Password)) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } else { VideoSource = "/StreamSource?shortenedUrl=" + shortenedUrl; VideoType = "video/" + mapping.Original.Split(".").Last(); return(Page()); } } else { var mapping = _context.Mapping.Find(Base62.Decode(shortenedUrl)); if (!string.IsNullOrWhiteSpace(mapping.Password)) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } else { VideoSource = "/StreamSource?shortenedUrl=" + shortenedUrl; VideoType = "video/" + mapping.Original.Split(".").Last(); return(Page()); } } }
private void PostAuthenticateRequest(object sender, EventArgs e) { var url = HttpContext.Current.Request.Path; var rootPathLength = Utils.ApplicationPath.Length; url = url.Length > rootPathLength?url.Substring(rootPathLength) : string.Empty; if (!url.StartsWith("!")) { return; } try { var pageInstanceId = Base62.Decode(url.Substring(1)); var pageUrl = PageFactory.GetUrlForPageInstanceId(pageInstanceId); if (string.IsNullOrEmpty(pageUrl)) { return; } var response = HttpContext.Current.Response; response.Status = "301 Moved Permanently"; response.AddHeader("Location", pageUrl); response.End(); } catch { // Let the rest of the URL handlers take care of this URL } }
public void Unicode() { var ascii = "سلام من اسکی هستم"; var base62 = Base62.Encode62(ascii); var ascii_back = Base62.Decode62(base62); Assert.Equal(ascii, ascii_back, StringComparer.Ordinal); }
public void Ascii() { var ascii = "Hello I'm ASCII"; var base62 = Base62.Encode62(ascii); var ascii_back = Base62.Decode62(base62); Assert.Equal(ascii, ascii_back, StringComparer.Ordinal); }
public IActionResult Decode([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "encoder/decode")] HttpRequest req) { if (!req.QueryString.HasValue) { return(new BadRequestObjectResult(Properties.Resources.Encoder_MissingDecodeQuery)); } return(new OkObjectResult(Base62.Decode(req.QueryString.Value.TrimStart('?')))); }
public void TryParse_InvalidValue_False() { const string invalidString = "המסלול-האקדמי-המכללה-למנהל"; var result = Base62.TryParse(invalidString, out var p); result.Should().BeFalse(); p.Value.Should().Be(0); p.ToString().Should().Be("0"); }
public IActionResult OnGet(string shortenedUrl) { if (shortenedUrl == null) { return(Page()); } else { if (shortenedUrl.Length > 5) { var mapping = _context.CustomMapping.Find(Base62.Decode(shortenedUrl)); if (mapping == null) { ErrorMessage = "Not Found"; return(Page()); } if (!string.IsNullOrWhiteSpace(mapping.Password)) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } return(Redirect(mapping.Original)); } else { var mapping = _context.Mapping.Find(Base62.Decode(shortenedUrl)); if (mapping == null) { ErrorMessage = "Not Found"; return(Page()); } if (!string.IsNullOrWhiteSpace(mapping.Password)) { return(RedirectToPage("./VerifyPassword", new { shortenedUrl = shortenedUrl })); } if (mapping.MappingType == MappingType.URL) { return(Redirect(mapping.Original)); } else if (mapping.MappingType == MappingType.IMAGE) { return(RedirectToPage("./ImageContent", new { shortenedUrl = shortenedUrl })); } else if (mapping.MappingType == MappingType.VIDEO) { return(RedirectToPage("./VideoContent", new { shortenedUrl = shortenedUrl })); } else if (mapping.MappingType == MappingType.AUDIO) { return(RedirectToPage("./AudioContent", new { shortenedUrl = shortenedUrl })); } else { return(BadRequest()); } } } }
/// <summary> /// Branca specification-level token generation /// </summary> /// <param name="payload">The payload to be encrypted into the Branca token</param> /// <param name="key">32-byte private key used to encrypt and decrypt the Branca token</param> /// <returns>Base62 encoded Branca Token</returns> public virtual string CreateToken(string payload, byte[] key) { if (string.IsNullOrWhiteSpace(payload)) { throw new ArgumentNullException(nameof(payload)); } if (!IsValidKey(key)) { throw new InvalidOperationException("Invalid encryption key"); } var nonce = new byte[24]; RandomNumberGenerator.Create().GetBytes(nonce); var timestamp = Convert.ToUInt32(DateTimeOffset.UtcNow.ToUnixTimeSeconds()); // header var header = new byte[29]; using (var stream = new MemoryStream(header)) { // version stream.WriteByte(0xBA); // timestamp stream.Write(BitConverter.GetBytes(timestamp), 0, 4); // nonce stream.Write(nonce, 0, nonce.Length); } var keyMaterial = new KeyParameter(key); var parameters = new ParametersWithIV(keyMaterial, nonce); var engine = new XChaChaEngine(); engine.Init(true, parameters); var plaintextBytes = Encoding.UTF8.GetBytes(payload); var ciphertext = new byte[plaintextBytes.Length + 16]; engine.ProcessBytes(plaintextBytes, 0, plaintextBytes.Length, ciphertext, 0); var poly = new Poly1305(); poly.Init(keyMaterial); poly.BlockUpdate(header, 0, header.Length); poly.DoFinal(ciphertext, plaintextBytes.Length); var tokenBytes = new byte[header.Length + ciphertext.Length]; Buffer.BlockCopy(header, 0, tokenBytes, 0, header.Length); Buffer.BlockCopy(ciphertext, 0, tokenBytes, header.Length, ciphertext.Length); return(Base62.Encode(tokenBytes)); }
public void ToBase62Chars8_WithOverlappingInputAndOutputSpans_ShouldReturnExpectedOutput(string text, string base62String) { Span <byte> bytes = stackalloc byte[11]; System.Text.Encoding.UTF8.GetBytes(text, bytes); Base62.ToBase62Chars8(bytes, bytes); var outputString = System.Text.Encoding.UTF8.GetString(bytes); Assert.Equal(base62String, outputString); }
public void FromBase62Chars11_Regularly_ShouldReturnExpectedOutput(string text, string base62String) { var chars = System.Text.Encoding.UTF8.GetBytes(base62String); Span <byte> outputBytes = stackalloc byte[text.Length]; Base62.FromBase62Chars11(chars, outputBytes); var originalString = System.Text.Encoding.UTF8.GetString(outputBytes); Assert.Equal(text, originalString); }
public void ToBase62Chars16_Regularly_ShouldReturnExpectedOutput(string text, string base62String) { var bytes = System.Text.Encoding.UTF8.GetBytes(text); Span <byte> outputChars = stackalloc byte[base62String.Length]; Base62.ToBase62Chars16(bytes, outputChars); var outputString = System.Text.Encoding.UTF8.GetString(outputChars); Assert.Equal(base62String, outputString); }
public void ValidateToken_CiphertextModification_ExpectSecurityTokenException() { var handler = new BrancaTokenHandler(); var token = handler.CreateToken("test", key); var decoded = Base62.Decode(token); decoded[decoded.Length - 17] ^= 1; // Last byte before the Poly1305 tag Assert.Throws <CryptographicException>(() => handler.DecryptToken(Base62.Encode(decoded), key)); }
public void CreateToken_WhenTokenGenerated_ExpectBas62EncodedTokenWithCorrectLength() { var payload = Guid.NewGuid().ToString(); var handler = new BrancaTokenHandler(); var token = handler.CreateToken(payload, validKey); token.Any(x => !Base62.CharacterSet.Contains(x)).Should().BeFalse(); Base62.Decode(token).Length.Should().Be( System.Text.Encoding.UTF8.GetBytes(payload).Length + 29 + 16); }
public void WithRandomBytes_ExpectCorrectValuesEncoded() { var bytes = new byte[128]; var rng = RandomNumberGenerator.Create(); rng.GetBytes(bytes); var encodedBytes = Base62.Encode(bytes); Base62.Decode(encodedBytes).Should().BeEquivalentTo(bytes); }
/// <summary> /// Branca specification level token decryption. /// </summary> /// <param name="token">Base62 encoded Branca token</param> /// <param name="key">32-byte private key used to encrypt and decrypt the Branca token</param> /// <returns>Pared and decrypted Branca Token</returns> public virtual BrancaToken DecryptToken(string token, byte[] key) { if (string.IsNullOrWhiteSpace(token)) { throw new ArgumentNullException(nameof(token)); } if (!CanReadToken(token)) { throw new InvalidCastException("Unable to read token"); } if (!IsValidKey(key)) { throw new InvalidOperationException("Invalid decryption key"); } var tokenBytes = Base62.Decode(token); using (var stream = new MemoryStream(tokenBytes, false)) { // header var header = GuaranteedRead(stream, 29); byte[] nonce; uint timestamp; using (var headerStream = new MemoryStream(header)) { // version var version = headerStream.ReadByte(); if (version != 0xBA) { throw new SecurityTokenException("Unsupported Branca version"); } // timestamp (big endian uint32) var timestampBytes = GuaranteedRead(headerStream, 4).Reverse().ToArray(); timestamp = BitConverter.ToUInt32(timestampBytes, 0); // nonce nonce = GuaranteedRead(headerStream, 24); } // ciphertext var ciphertextLength = stream.Length - stream.Position - TagLength; var ciphertext = GuaranteedRead(stream, (int)ciphertextLength); var tag = GuaranteedRead(stream, TagLength); var plaintext = new byte[ciphertextLength]; new XChaCha20Poly1305(key).Decrypt(nonce, ciphertext, tag, plaintext, header); return(new BrancaToken( Encoding.UTF8.GetString(plaintext), timestamp)); } }
public Request( string personId, int amount, string description, string[]?keywords = default) : this() { IsReadOnly = false; // Requests only need to be unique within a person, so we use that as the prefix to disambiguate // multiple requests at the same UtcNow. The high-precision time also helps make that unique too. Raise(new RequestCreated(personId + "-" + Base62.Encode(PreciseTime.UtcNow.Ticks), amount, description, keywords, personId: personId)); }
public Link CreateShortUrl(string url) { Link link = new Link(); link.Redir = url; db.Links.Add(link); db.SaveChanges(); // Now we generate a Base36 string for the DB id: link.Hash = Base62.Encode(link.Id); db.SaveChanges(); return(link); }
/// <summary> /// <para> /// Outputs an 11-character alphanumeric string representation of the given ID. /// </para> /// <para> /// Throws if the output span is too short. /// </para> /// </summary> /// <param name="id">The ID to encode.</param> /// <param name="bytes">At least 11 bytes, to write the alphanumeric representation to.</param> public static void GetAlphanumeric(ulong id, Span <byte> bytes) { if (bytes.Length < 11) { throw new IndexOutOfRangeException("At least 11 output bytes are required."); } // Abuse the caller's output span as input space BinaryPrimitives.WriteUInt64BigEndian(bytes, id); Base62.ToBase62Chars8(bytes, bytes); }
public void WithUtf8Characters_ExpectCorrectValuesEncoded(string testValue, string expectedResult) { var testBytes = System.Text.Encoding.UTF8.GetBytes(testValue); var result = Base62.Encode(testBytes); result.Should().Be(expectedResult); var decodedBytes = Base62.Decode(result); decodedBytes.Should().BeEquivalentTo(testBytes); }
static void Main(string[] args) { for (int i = 0; i < 100; i++) { string str = Base62.Encode(i); Console.Write($"{str}:{Base62.Decode(str)}\t"); if (i % 10 == 0) { Console.WriteLine(); } } Console.ReadKey(); }
public static string Decompress(string compressedUrl, Dictionary <string, string> hostConversions = null) { InitHuffmanTree(); byte[] urlBytes = Base62.Decode(compressedUrl); urlBytes = ChecksumCheck(urlBytes); urlBytes = _huffmanTree.Decode(urlBytes); string url = Encoding.ASCII.GetString(urlBytes); Url oUrl = Url.CreateFromShortString(url); // "Decompress" protocol if (oUrl.Protocol == "#") { oUrl.Protocol = "http"; } else if (oUrl.Protocol == "$") { oUrl.Protocol = "https"; } else if (oUrl.Protocol == "F") { oUrl.Protocol = "ftp"; } else { throw new Exception(string.Format("Unkown protocol \"{0}\"", oUrl.Protocol)); } if (hostConversions != null) { // "Decompress" hosts string[] urlHostParts = oUrl.Host.Split('.'); for (int i = 0; i < urlHostParts.Length; i++) { foreach (KeyValuePair <string, string> hostConversion in hostConversions) { if (urlHostParts[i] == hostConversion.Value) { urlHostParts[i] = hostConversion.Key; break; } } } oUrl.Host = string.Join(".", urlHostParts); } url = oUrl.ToString(); return(url); }
public Token(DateTime tokenDate) { var partitionKey = Base62.FromDate(tokenDate); if (partitionKey.Length < 4) { partitionKey = partitionKey.PadLeft(4, '0'); } else if (partitionKey.Length > 4) { partitionKey = partitionKey.Substring(0, 4); } PartitionKey = partitionKey; RowKey = Base62.Encode(RandomNumber.Next(1, 10_000_000)); }
public async Task <IActionResult> OnGet(string shortenedUrl) { if (shortenedUrl.Length > 5) { var mapping = await _context.CustomMapping.FindAsync(Base62.Decode(shortenedUrl)); if (mapping.MappingType == MappingType.URL) { FormAction = "/VerifyPassword"; } else if (mapping.MappingType == MappingType.IMAGE) { FormAction = "/ImageContent"; } else if (mapping.MappingType == MappingType.VIDEO) { FormAction = "/VideoContent"; } else if (mapping.MappingType == MappingType.AUDIO) { FormAction = "/AudioContent"; } } else { var mapping = await _context.Mapping.FindAsync(Base62.Decode(shortenedUrl)); if (mapping.MappingType == MappingType.URL) { FormAction = "/VerifyPassword"; } else if (mapping.MappingType == MappingType.IMAGE) { FormAction = "/ImageContent"; } else if (mapping.MappingType == MappingType.VIDEO) { FormAction = "/VideoContent"; } else if (mapping.MappingType == MappingType.AUDIO) { FormAction = "/AudioContent"; } } ShortenedUrl = shortenedUrl; return(Page()); }
/// <summary> /// Branca specification-level token generation /// </summary> /// <param name="payload">The payload to be encrypted into the Branca token</param> /// <param name="timestamp">The timestamp included in the Branca token (iat: issued at)</param> /// <param name="key">32-byte private key used to encrypt and decrypt the Branca token</param> /// <returns>Base62 encoded Branca Token</returns> public virtual string CreateToken(string payload, uint timestamp, byte[] key) { if (string.IsNullOrWhiteSpace(payload)) { throw new ArgumentNullException(nameof(payload)); } if (!IsValidKey(key)) { throw new InvalidOperationException("Invalid encryption key"); } var nonce = new byte[24]; using (var rng = RandomNumberGenerator.Create()) { rng.GetBytes(nonce); } // header var header = new byte[29]; using (var stream = new MemoryStream(header)) { // version stream.WriteByte(0xBA); // timestamp (big endian uint32) stream.Write(BitConverter.GetBytes(timestamp).Reverse().ToArray(), 0, 4); // nonce stream.Write(nonce, 0, nonce.Length); } var plaintext = Encoding.UTF8.GetBytes(payload); var ciphertext = new byte[plaintext.Length]; var tag = new byte[TagLength]; new XChaCha20Poly1305(key).Encrypt(nonce, plaintext, ciphertext, tag, header); var tokenBytes = new byte[header.Length + ciphertext.Length + TagLength]; Buffer.BlockCopy(header, 0, tokenBytes, 0, header.Length); Buffer.BlockCopy(ciphertext, 0, tokenBytes, header.Length, ciphertext.Length); Buffer.BlockCopy(tag, 0, tokenBytes, tokenBytes.Length - TagLength, tag.Length); return(Base62.Encode(tokenBytes)); }