A new book: Computational Commutative Algebra and Algebraic Geometry: Course and exercises with detailed solutions

This book is intended to provide material for a graduate course of one or two semesters on computational commutative algebra and algebraic geometry spotlighting potential applications in cryptography. Also, the topics in this book could form the basis of a graduate course that acts as a segue between an introductory algebra course and the more technical topics of commutative algebra and algebraic geometry. It contains a total of 124 exercises (15 on Gröbner bases over arithmetical rings, 11 on Varieties, Ideals and Gröbner bases, 19 on Finite fields, 11 on Algorithms for cryptography, 33 on Algebraic plane curves, and finally 35 on Elliptic curves) with detailed solutions as well as an important number of examples that illustrate definitions, theorems, and methods. This is very important for students or researchers who are not familiar with the topics discussed. Experience has shown that beginners who want to take their first steps in algebraic geometry are usually discouraged by the difficulty of the proposed exercises and the absence of detailed answers. So, exercises (and their solutions) as well as examples occupy a prominent place in this course. This book is not designed as a comprehensive reference work, but rather as a selective textbook. The many exercises with detailed answers make it suitable for use both in a math or computer science course. Please see the link: https://www.amazon.com/dp/1096374447?ref_=pe_3052080_397514860

View detailed url history on CLI

I saw this question: Can I view Firefox history with the terminal?

Here i can see the url’s I visited. But this only show the main link. When you use dev tools in your browser, you see more links like get requests etc. I want to see those links on the CLI.

Does somebody know where I can get it? Is qt3-dev-tools an option? I can’t find how that works.

Is it required to provide a detailed itinerary for Schengen visa?

Is it required to give a detailed itinerary like this for a Schengen Visa application?

Or is it enough to provide a basic itinerary like this?

1-June to 3-June in Rome 3-June to 6-June in Milan 6-June to 10-June in Zurich 

I don’t see any requirement asking for a “detailed” itinerary as per the documents required.

Can someone guide me here?

Where can I find more detailed documentation about the secp256k1 lib?

I’m basically reading the header file’s comments and some of the code.

In particular, I’m interested in more explanations about the tweak options for addition and multiplication, and their applications to both private and public keys.

I’ll pick an example from secp256k1.c file in source:

int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) { secp256k1_scalar term; secp256k1_scalar sec; int ret = 0; int overflow = 0; VERIFY_CHECK(ctx != NULL); ARG_CHECK(seckey != NULL); ARG_CHECK(tweak != NULL);  secp256k1_scalar_set_b32(&term, tweak, &overflow); secp256k1_scalar_set_b32(&sec, seckey, NULL);  ret = !overflow && secp256k1_eckey_privkey_tweak_add(&sec, &term); memset(seckey, 0, 32); if (ret) {     secp256k1_scalar_get_b32(seckey, &sec); }  secp256k1_scalar_clear(&sec); secp256k1_scalar_clear(&term); return ret; 


And the functions secp256k1_scalar_set_b32() and secp256k1_scalar_get_b32() appear to be related to the partitioning of the 32 bytes of the scalar in into either 4×64 bits, or 8×32 bits (or something else) to do group operations. Just looking at the code is not very clear to me.

In the comments to secp256k1_context_randomize() it is said, quote “secp256k1 code is written to be constant-time no matter what secret”. So, in broad strokes, are the tweaks a way to bypass the overall construction that makes the whole implementation constant-time (due to side-channel leakage prevention)?

I’d appreciate pointing to references in the literature as well.

Detailed Life of a packet

I would know some reference to a detailed analysis of how packets are generated inthe android device, how they are process like through the TCP/IP stack and how they are sent.

Kindly point out to me any such reference or any such answer, in brief, is highly appreciated. Thank you

“Detailed” exception class hierarchy

I’m designing an modular exception class hierarchy to use in various projects. I intend to inherit from std::exception in order to be maximally compatible with any exception-handling code. A design goal is that each exception’s what() method returns a string which contains a base message, which is dependent on the object’s most specific class (i.e. equal for all objects of the class), and an optional instance-specific details message which specifies the origin of the exception.

The two main goals are ease of use (as in when throwing the exceptions), as well as ensuring that writing another exception subclass is as simple and repetition-free as possible.

Base class

The base exception class I wrote is the following. It is conceptually an abstract class, but not syntactically, since I don’t have any virtual method to make pure virtual. So, as an alternative, I made all constructors protected.

/**  * Base class for all custom exceptions. Stores a message as a string.  * Instances can only be constructed from within a child class,  * since the constructors are protected.  */ class BaseException : public std::exception { protected:     std::string message;  ///< message to be returned by what()      BaseException() = default;      /**      * Construct a new exception from a base message and optional additional details.      * The base message is intended to be class-specific, while the additional      * details string is intended to be instance-specific.      *      * @param baseMessage  generic message for the kind of exception being created      * @param details  additional information as to why the exception was thrown      */     BaseException(const std::string &baseMessage, const std::string &details = "") {         std::ostringstream oss(baseMessage, std::ios::ate);         if (not details.empty()) oss << " (" << details << ')';         message = oss.str();     }  public:     /// `std::exception`-compliant message getter     const char *what() const noexcept override {         return message.c_str();     } }; 

The intention of the above design is that any subclass of BaseException defines a constructor that passes a class-specific base message (as the baseMessage paramter) and an optional detail-specifier (as the details parameter) as arguments to BaseException‘s constructor.

Errors & warnings

Since I want to be able to differentiate between general exception “types”, e.g. errors vs. warnings, I’ve made the following two virtually-inherited bases:

class Error: public virtual BaseException {};  class Warning : public virtual BaseException {}; 


Here are some (project-specific) examples of implementing concrete exception subclasses with this design:

/// Indicates that a command whose keyword is unknown was issued class UnknownCommand : public Error { public:     static constexpr auto base = "unrecognized command";     UnknownCommand(const std::string &specific = "") : BaseException(base, specific) {} };   /// Indicates an error in reading or writing to a file class IOError : public Error { public:     static constexpr auto base = "unable to access file";     IOError(const std::string &specific = "") : BaseException(base, specific) {} };   /// Indicates that an algorithm encountered a situation in which it is not well-defined; /// i.e., a value that doesn't meet a function's prerequisites was passed. class ValueError : public Error { public:     static constexpr auto base = "invalid value";     ValueError(const std::string &specific = "") : BaseException(base, specific) {} };  # [...]  

As you can see, the common pattern is

class SomeException : public Error /* or Warning */ { public:     static constexpr auto base = "some exception's generic description";     SomeException(const std::string &details) : BaseException(base, details) {} } 

Usage example

Taking the previous IOError class as an example:

#include <iostream> #include <fstream> #include "exceptions.h"  // all of the previous stuff  void cat(const std::string &filename) {     std::ifstream file(filename);     if (not file.is_open()) throw IOError(filename);     std::cout << file.rdbuf(); }  int main(int argc, char **argv) {     for (int i = 1; i < argc; ++i) {         try { cat(argv[i]); }         catch (std::exception &e) { std::cerr << e.what() << '\n'; }     } } 

In case of calling the program with an inaccessible file path, e.g. the path “foo”, it should output

unable to access file (foo) 

I need detailed instruction on how to recover a zte z828 lt from soft brick caused by kingoroot!

I need detailed instruction on how to recover a zte z828tl from soft brick caused by Kingo root! I bought this “simple mobile ZTE Midnight pro LTE”, off eBay, and simple won’t unlock it so I can use it with anyone else, so I was playing with KingoRoot trying to root it, the computer version said root complete please donate, the phone rebooted into boot loop, I can access the stock recovery screen, but can’t do a factory reset, and I can get to ftn!!! Please help, I am a newbie to android, cell phones, but have messed with tablets for years, and usually can get a factory rom restore for flashing, but this time I’ve searched all over without any lUck..

What is the use of disabling detailed exception pages on open-sourced apps?

Frameworks for web apps typically can run in either production mode or development mode. One of the major differences between the two modes is how exceptions are handled: in development mode the browser will typically be sent a detailed exception information with a stack trace, while production mode will only serve a generic (though customizable) error page that is devoid of any more detailed information.

The frameworks’ documentation will also typically warn against using development mode in production for this reason; this is an example from .NET Core:

Warning Enable the Developer Exception Page only when the app is running in the Development environment. You don’t want to share detailed exception information publicly when the app runs in production.

And this is a similar warning from Django docs:

Never deploy a site into production with DEBUG turned on.

One of the main features of debug mode is the display of detailed error pages. If your app raises an exception when DEBUG is True, Django will display a detailed traceback, including a lot of metadata about your environment, such as all the currently defined Django settings (from settings.py).

I’m failing to understand the reasoning behind the aforementioned security measures?

If I understand, the reasoning goes like that: Detailed error pages would allow a potential attacker to discover details about the app’s source code = they might find weaknesses = bad. Isn’t it the definition of security through obscurity?

In addition: What is the use of such measures if the app is open-sourced? Disabling detailed exception pages is supposed to prevent the attacker from finding out details about its source code, but these are – by design – present in a public GitHub repository. Seemingly in this case I might just as well run the app in development mode, at least if there is an unexpected bug a user finds out they will be able to give me a more detailed information that might help me fix this bug?

If the reasoning behind the documentation warnings I quoted above is correct, then this would mean to me that developing open-sourced webapps is itself a security vulnerability! Because if allowing an attacker to find some details abou the source code is such a big deal, then how worse must it be to simply give out the source code to anyone interested! And yet, AFAIK, open source is not considered an invalid and inherently insecure model.

What am I missing here? Why should detailed exception pages be disabled?

Digital Marketing Course in Delhi provides detailed Knowledge

The growth opportunities in the digital marketing industry attract many youngsters to make a career in this field. Digital Marketing Course in Delhi is offering an industry-oriented training program. The program covers different aspects of digital marketing, such as SEO, SMO, PPC management, etc. To give your career a perfect start, enroll with Digital Marketing