Пример #1
0
        public static string encrypt(string toEncrypt)
        {
            if (toEncrypt == null)
            {
                return(null);
            }
            byte[] data = System.Text.Encoding.UTF8.GetBytes(toEncrypt);
            Sha256 sha  = new Sha256();

            sha.AddData(data, 0, (uint)data.Length);

            ICollection <byte> hash     = sha.GetHash();
            string             hashPass = Sha256.ArrayToString(hash.ToList <byte>());

            return(hashPass);
        }
Пример #2
0
        public ActionResult <Member> Authenticate([FromQuery] string nickname, [FromQuery] string password)
        {
            if (nickname is null)
            {
                return(BadRequest("The username is not provided"));
            }

            if (password is null)
            {
                return(BadRequest("The password is not provided"));
            }

            var member = UnitOfWork.MemberRepository.GetByNickname(nickname);

            if (member.Password?.ToLower() != Sha256.GetHash(password).ToLower())
            {
                throw new AuthenticationException("Incorrect Password");
            }

            member.Token = Token.IssueAccountAccess(TimeSpan.FromDays(30), member);
            return(Ok(member.WithoutPassword()));
        }
Пример #3
0
        public static bool TryWrite(Span <byte> output, Sha256 hash, string verb, string canonicalizedResource, DateTime utc, out int bytesWritten)
        {
            int written, consumed;

            bytesWritten = 0;

            if (verb.Equals("GET", StringComparison.Ordinal))
            {
                if (output.Length < 3)
                {
                    bytesWritten = 0;
                    return(false);
                }
                s_GET.CopyTo(output);
                bytesWritten += s_GET.Length;
            }
            else
            {
                if (Utf16.ToUtf8(verb.AsReadOnlySpan().AsBytes(), output, out consumed, out written) != TransformationStatus.Done)
                {
                    bytesWritten = 0;
                    return(false);
                }

                output[written] = (byte)'\n';
                bytesWritten   += written + 1;
            }

            var free = output.Slice(bytesWritten);

            s_emptyHeaders.CopyTo(free);
            bytesWritten += s_emptyHeaders.Length;

            free = output.Slice(bytesWritten);
            if (!Text.Formatters.Utf8.TryFormat(utc, free, out written, 'R'))
            {
                bytesWritten = 0;
                return(false);
            }
            free[written] = (byte)'\n';
            bytesWritten += written + 1;
            free          = output.Slice(bytesWritten);

            if (Utf16.ToUtf8(canonicalizedResource.AsReadOnlySpan().AsBytes(), free, out consumed, out written) != TransformationStatus.Done)
            {
                bytesWritten = 0;
                return(false);
            }
            bytesWritten += written;

            var formatted = output.Slice(0, bytesWritten);

            hash.Append(formatted);
            hash.GetHash(output.Slice(0, hash.OutputSize));

            if (!Base64.EncodeInPlace(output, hash.OutputSize, out written))
            {
                bytesWritten = 0;
                return(false);
            }

            bytesWritten = written;
            return(true);
        }
        public static bool TryWrite(Span <byte> output, Sha256 hash, string keyType, string verb, string resourceId, string resourceType, string tokenVersion, DateTime utc, out int bytesWritten)
        {
            int written, consumed, totalWritten = 0;

            bytesWritten = 0;

            Span <byte> buffer;

            unsafe
            {
                var pBuffer = stackalloc byte[AuthenticationHeaderBufferSize];
                buffer = new Span <byte>(pBuffer, AuthenticationHeaderBufferSize);
            }

            s_type.CopyTo(buffer);
            totalWritten += s_type.Length;
            var bufferSlice = buffer.Slice(totalWritten);

            if (Utf16.ToUtf8(keyType.AsReadOnlySpan().AsBytes(), bufferSlice, out consumed, out written) != TransformationStatus.Done)
            {
                throw new NotImplementedException("need to resize buffer");
            }
            totalWritten += written;
            bufferSlice   = buffer.Slice(totalWritten);

            s_ver.CopyTo(bufferSlice);
            totalWritten += s_ver.Length;

            bufferSlice = buffer.Slice(totalWritten);

            if (Utf16.ToUtf8(tokenVersion.AsReadOnlySpan().AsBytes(), bufferSlice, out consumed, out written) != TransformationStatus.Done)
            {
                throw new NotImplementedException("need to resize buffer");
            }
            totalWritten += written;
            bufferSlice   = buffer.Slice(totalWritten);

            s_sig.CopyTo(bufferSlice);
            totalWritten += s_sig.Length;

            var front = buffer.Slice(0, totalWritten);

            var payload = buffer.Slice(totalWritten);

            totalWritten = 0;

            if (verb.Equals("GET", StringComparison.Ordinal) || verb.Equals("get", StringComparison.Ordinal))
            {
                s_get.CopyTo(payload);
                totalWritten += s_get.Length;
            }
            else if (verb.Equals("POST", StringComparison.Ordinal) || verb.Equals("post", StringComparison.Ordinal))
            {
                s_post.CopyTo(payload);
                totalWritten += s_post.Length;
            }
            else if (verb.Equals("DELETE", StringComparison.Ordinal) || verb.Equals("delete", StringComparison.Ordinal))
            {
                s_delete.CopyTo(payload);
                totalWritten += s_delete.Length;
            }
            else
            {
                if (Utf16.ToUtf8(verb.AsReadOnlySpan().AsBytes(), payload, out consumed, out written) != TransformationStatus.Done)
                {
                    throw new NotImplementedException("need to resize buffer");
                }
                if (Ascii.ToLowerInPlace(payload.Slice(0, written), out written) != TransformationStatus.Done)
                {
                    throw new NotImplementedException("need to resize buffer");
                }

                payload[written] = (byte)'\n';
                totalWritten    += written + 1;
            }

            bufferSlice = payload.Slice(totalWritten);

            if (Utf16.ToUtf8(resourceType.AsReadOnlySpan().AsBytes(), bufferSlice, out consumed, out written) != TransformationStatus.Done)
            {
                throw new NotImplementedException("need to resize buffer");
            }
            if (Ascii.ToLowerInPlace(bufferSlice.Slice(0, written), out written) != TransformationStatus.Done)
            {
                throw new NotImplementedException("need to resize buffer");
            }
            bufferSlice[written] = (byte)'\n';
            totalWritten        += written + 1;
            bufferSlice          = payload.Slice(totalWritten);

            if (Utf16.ToUtf8(resourceId.AsReadOnlySpan().AsBytes(), bufferSlice, out consumed, out written) != TransformationStatus.Done)
            {
                throw new NotImplementedException("need to resize buffer");
            }
            bufferSlice[written] = (byte)'\n';
            totalWritten        += written + 1;
            bufferSlice          = payload.Slice(totalWritten);

            if (!Text.Formatters.Utf8.TryFormat(utc, bufferSlice, out written, 'l'))
            {
                throw new NotImplementedException("need to resize buffer");
            }
            bufferSlice[written] = (byte)'\n';
            totalWritten        += written + 1;
            bufferSlice          = payload.Slice(totalWritten);

            bufferSlice[0] = (byte)'\n';
            totalWritten  += 1;

            hash.Append(buffer.Slice(front.Length, totalWritten));
            hash.GetHash(buffer.Slice(front.Length, hash.OutputSize));
            if (!Base64.EncodeInPlace(buffer.Slice(front.Length), hash.OutputSize, out written))
            {
                throw new NotImplementedException("need to resize buffer");
            }

            var len = front.Length + written;

            if (!UrlEncoder.TryEncode(buffer.Slice(0, len), output, out bytesWritten))
            {
                bytesWritten = 0;
                return(false);
            }
            return(true);
        }
Пример #5
0
        private async void CreateBroadcastTableButton_Click(object sender, EventArgs e)
        {
            loadFromExcelButton.Enabled = false;

            startSendingButton.Enabled = false;

            createBroadcastTableButton.Enabled = false;

            _mediaFilesList = Utils.LoadMediaFilesList(_currentDir, _broadcastsToSend);

            int id = 0;

            foreach (var broadcast in _broadcastsToSend)
            {
                if (broadcast.Id > id)
                {
                    id = broadcast.Id;
                }
            }

            int count = 0;

            foreach (var fileName in _mediaFilesList)
            {
                string[] mediaInfo = Utils.ParseFileName(fileName, CurrentYear);

                mediaInfo[5] = Utils.ParsePresenters(mediaInfo[5]);

                Broadcast broadcast = new Broadcast()
                {
                    Id         = ++id,
                    DateAired  = mediaInfo[2] + " " + mediaInfo[3],
                    Date       = mediaInfo[2],
                    Time       = mediaInfo[3],
                    Author     = mediaInfo[5],
                    Presenters = mediaInfo[5],
                    FileName   = mediaInfo[6],
                    FileExists = true
                };

                try
                {
                    broadcast.Title = Utils.Titles[mediaInfo[1].ToLower()];
                }
                catch (KeyNotFoundException)
                {
                    MessageBox.Show($"Программа \"{mediaInfo[1]}\" не найдена в перечне!");
                    Process.GetCurrentProcess().Kill();
                }

                if (mediaInfo[0] == "combined")
                {
                    broadcast.DateAiredEnd = mediaInfo[4];
                }

                broadcast.Anons = Utils.Anons[broadcast.Title.ToLower()];
                if (broadcast.DateAiredEnd == "-")
                {
                    broadcast.Fragments = "В прилагаемом файле выпуск программы от " + broadcast.Date + ".";
                }
                else
                {
                    broadcast.Fragments = "В прилагаемом файле выпуски программы, вышедшие с " + mediaInfo[2] + " по " +
                                          mediaInfo[4];
                }

                broadcast.Director = Utils.GetDirector(broadcast, Utils.Directors, Utils.DirectorsSchedule);

                broadcast.Sha256 = await Task.Run(() => Sha256.GetHash(@".\MP3\" + fileName + ".mp3"));

                _broadcastsToSend.Add(broadcast);

                broadcastTotalNumberLabel.Text = _broadcastsToSend.Count().ToString();

                await ExcelInteraction.WriteBroadcastToTableAsync(broadcast);

                count++;

                progressBar.Value = count * 100 / _mediaFilesList.Count();

                try
                {
                    richTextBox1.Text += broadcast.Id + ": " + broadcast.Title + " (" + broadcast.Date + ")\n";
                    richTextBox1.Select(richTextBox1.Text.Length, 0);
                    richTextBox1.ScrollToCaret();
                }
                catch (ObjectDisposedException)
                {
                }
            }

            try
            {
                richTextBox1.Text += "\nТаблица заполнена!\n";
                richTextBox1.Select(richTextBox1.Text.Length, 0);
                richTextBox1.ScrollToCaret();
            }
            catch (ObjectDisposedException)
            {
            }

            MessageBox.Show("Таблица заполнена!", "Внимание!", MessageBoxButtons.OK, MessageBoxIcon.Information);

            if (_broadcastsToSend.Any() && _userLoggedIn)
            {
                startSendingButton.Enabled = true;
            }

            loadFromExcelButton.Enabled = true;
        }